diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 6361d80070..e1c81f68f8 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -6,7 +6,7 @@ name: CI # events but only for the master branch on: push: - branches: [ master ] + branches: [ master; 500 ] paths-ignore: - '**.md' - '**.txt' @@ -38,9 +38,9 @@ jobs: os: - macos-latest - ubuntu-latest - - windows-latest + # - windows-latest ocaml-compiler: - - 4.14.x + - 5.2.x # The type of runner that the job will run on runs-on: ${{ matrix.os }} @@ -51,12 +51,12 @@ jobs: # Steps represent a sequence of tasks that will be executed as part of the job steps: # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it - - uses: actions/checkout@v3 + - name: Checkout tree + uses: actions/checkout@v4 - - name: Set up OCaml ${{ matrix.ocaml-compiler }} + - name: Set-up OCaml ${{ matrix.ocaml-compiler }} uses: ocaml/setup-ocaml@v2 with: - # Version of the OCaml compiler to initialise ocaml-compiler: ${{ matrix.ocaml-compiler }} - name: Install dependencies diff --git a/.github/workflows/ocaml-lsp-compat.yml b/.github/workflows/ocaml-lsp-compat.yml index 9d90af58db..79a2641f21 100644 --- a/.github/workflows/ocaml-lsp-compat.yml +++ b/.github/workflows/ocaml-lsp-compat.yml @@ -34,7 +34,7 @@ jobs: os: - ubuntu-latest ocaml-compiler: - - 4.14.x + - 5.2.x # The type of runner that the job will run on runs-on: ${{ matrix.os }} diff --git a/CHANGES.md b/CHANGES.md index ea217dc137..2e5045ce0b 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -2,6 +2,7 @@ merlin NEXT_VERSION ================== + merlin binary + - Support for OCaml 5.2 (#1757) - destruct: Removal of residual patterns (#1737, fixes #1560) - Do not erase fields' names when destructing punned record fields (#1734, fixes #1661) @@ -14,6 +15,8 @@ merlin 4.14 Thu Feb 22 14:00:42 CET 2024 + merlin binary + - Preliminary support for OCaml 5.2 + - Some regressions in recovery and destruct are present. - Add a "heap_mbytes" field to Merlin server responses to report heap usage (#1717) - Add cache stats to telemetry (#1711) - Add new SyntaxDocument command to find information about the node under the cursor (#1706) @@ -28,18 +31,21 @@ Thu Feb 22 14:00:42 CET 2024 - vim: load merlin under the ocamlinterface and ocamllex filetypes (#1340) - Fix merlinpp not using binary file open (#1725, fixes #1724) -merlin 4.13 -=========== +merlin 4.13.1 +============= Fri Dec 1 15:00:42 CET 2023 + merlin binary - Fix a follow-up issue to the preference of non-ghost nodes introduced in #1660 (#1690, fixes #1689) - Add `-cache-lifespan` flag, that sets cache invalidation period. (#1698, #1705) + - Ignore the new 5.1 `cmi-file` flag instead of rejecting it (#1710, fixes + #1703) - Fix Merlin locate not fallbacking on the correct file in case of ambiguity (@goldfirere, #1699) - Fix Merlin reporting errors provoked by the recovery itself (#1709, fixes #1704) + - Add support for OCaml 5.1.1 (#1714) + editor modes - vim: load merlin when Vim is compiled with +python3/dyn (e.g. MacVim) - emacs: highlight only first error line by default (#1693, fixes #1663) @@ -59,6 +65,7 @@ merlin 4.11 Thu Sep 24 18:01:42 CEST 2023 + merlin binary + - Add support for OCaml 5.1 - Improve error messages for missing configuration reader (#1669) - Fix regression causing crash when using ppxes under Windows (#1673) - Fix confusion between aliased modules and module types (#1676, @@ -75,7 +82,7 @@ Thu Sep 24 18:01:42 CEST 2023 - emacs: remove use of obsolete `defadvice` macro (#1675) merlin 4.10 -========== +=========== Thu Aug 24 17:17:42 CEST 2023 + merlin binary @@ -106,9 +113,11 @@ Thu Aug 24 17:17:42 CEST 2023 merlin 4.9 ========== -Fri May 26 15:23:42 CEST 2023 +unreleased + merlin binary + - Preview support for OCaml 5.1-alpha1. Short path is temporary disabled and + inline records might not behave as expected. - Allow monadic IO in dot protocol (#1581) - Add a `scope` option to the `occurrences` command in preparation for the upcoming `project-wide-occurrences` feature (#1596) @@ -141,11 +150,15 @@ merlin 4.8 Fri Feb 24 16:55:42 CEST 2023 + merlin binary - - Update internal typer to match OCaml 4.14.1 release (#1557) + - Recognize OCaml 5.0 cmi magic number in compiler version mismatch message + (#1554, fixes #1553) + - Upgrade Merlin from the RC2 to the stable 5.0.0 compiler release (#1559, + fixes #1558) - Improve type-enclosing behaviour when used on records' labels (#1565, fixes #1564) - - Restore compatibility with some OCaml compiler's debug flags that were - incorrectly rejected by Merlin (#1556) + - Restore compatibility with the compiler's command line by accepting the + `-safe-string` flag as a no-op instead of rejecting it (#1544, fixes + #1518) - Traverse aliases when jumping to declaration. This matches jump-to-definition's behavior (#1563) - Improve locate's behavior in various ill-typed expressions (#1546, fixes @@ -155,13 +168,29 @@ Fri Feb 24 16:55:42 CEST 2023 fixes #1540) - On Windows, change to a harmless directory when launching server to avoid locking down current directory (#1569, fixes #1474) + + editor modes + - emacs: Fix misuse of `eq` comparison (#1549, @mattiase) + - emacs: xref works from context menus; better highlighting of xref matches; + xref recognises operators and binding operators at the cursor position; + bad locations are filtered out (#1385, fixes #1410, @mattiase) + test suite - Add multiple tests for locate over ill-typed expressions (#1546) - Add non-regression tests for other fixes in this release + - Add a test for incorrect alert defaults (#1559) + +merlin 4.7.1 +============ +Thu Dec 13 11:49:42 CEST 2022 + + + merlin binary + - Restore compatibility with the compiler's command line by accepting + the `-safe-string` flag as a no-op instead of rejecting it. (#1544, + fixes #1518) + - Mark some C variables as unused to remove warnings (#1541, @antalsz) merlin 4.7 ========== -Thu Nov 24 13:31:42 CEST 2022 +Thu Nov 24 17:49:42 CEST 2022 + merlin binary - Replace custom "holes" AST nodes by extensions. This restores binary diff --git a/README.md b/README.md index 2716b6400d..842a559310 100644 --- a/README.md +++ b/README.md @@ -178,9 +178,9 @@ If you're a Merlin user and depend on our public API, we recommend that you cont Next Steps ========== -To use Merlin with a multi-file project, it is necessary to have a [.merlin](https://github.com/ocaml/merlin/wiki/project-configuration) file, +To use Merlin with a multi-file project, it is necessary to have a [.merlin](https://github.com/ocaml/merlin/wiki/project-configuration) file, unless your project is built using Dune. -Note that, in a project using Dune, user-created `.merlin` files will take precedence over the configuration provided by Dune to Merlin. +Note that, in a project using Dune, user-created `.merlin` files will take precedence over the configuration provided by Dune to Merlin. Read more in the [wiki](https://github.com/ocaml/merlin/wiki) to learn how to make full use of Merlin in your projects. diff --git a/dot-merlin-reader.opam b/dot-merlin-reader.opam index 48ead45bf7..67bfc002e2 100644 --- a/dot-merlin-reader.opam +++ b/dot-merlin-reader.opam @@ -11,7 +11,7 @@ build: [ ["dune" "build" "-p" name "-j" jobs] ] depends: [ - "ocaml" {>= "4.08" & < "5.0"} + "ocaml" {>= "5.2" } "dune" {>= "2.9.0"} "merlin-lib" {>= "4.9"} "ocamlfind" {>= "1.6.0"} diff --git a/merlin-lib.opam b/merlin-lib.opam index 1a9eb26aa1..8f4e8c3e26 100644 --- a/merlin-lib.opam +++ b/merlin-lib.opam @@ -10,7 +10,7 @@ build: [ ["dune" "build" "-p" name "-j" jobs] ] depends: [ - "ocaml" {>= "4.14" & < "4.15"} + "ocaml" {>= "5.2" & < "5.3"} "dune" {>= "2.9.0"} "csexp" {>= "1.5.1"} "menhir" {dev & >= "20201216"} diff --git a/merlin.opam b/merlin.opam index 907a1b3aa8..f118ce4ef8 100644 --- a/merlin.opam +++ b/merlin.opam @@ -11,7 +11,7 @@ build: [ ["dune" "runtest" "-p" name "-j" jobs] {with-test} ] depends: [ - "ocaml" {>= "4.14" & < "4.15"} + "ocaml" {>= "5.2" & < "5.3"} "dune" {>= "2.9.0"} "merlin-lib" {= version} "dot-merlin-reader" {>= "4.9"} diff --git a/src/analysis/ast_iterators.ml b/src/analysis/ast_iterators.ml new file mode 100644 index 0000000000..5d95ff1ee4 --- /dev/null +++ b/src/analysis/ast_iterators.ml @@ -0,0 +1,51 @@ +open Std +open Typedtree + +let {Logger. log} = Logger.for_section "iterators" + +(* The compiler contains an iterator that aims to gather definitions but +ignores local values like let-in expressions and local type definition. To +provide occurrences in the active buffer we extend the compiler's iterator with +these cases. *) +let iter_on_defs ~uid_to_locs_tbl = + let log = log ~title:"iter_on_defs" in + let register_uid uid fragment = + let loc = Misc_utils.loc_of_decl ~uid fragment in + Option.iter loc ~f:(fun loc -> + Types.Uid.Tbl.add uid_to_locs_tbl uid loc) + in + let iter_decl = Cmt_format.iter_on_declarations ~f:register_uid in + let register_uid uid loc = + Types.Uid.Tbl.add uid_to_locs_tbl uid loc + in + { iter_decl with + expr = (fun sub ({ exp_extra; _ } as expr) -> + List.iter exp_extra ~f:(fun (exp_extra, _loc, _attr) -> + match exp_extra with + | Texp_newtype' (typ_id, typ_name, uid) -> + log "Found newtype %s wit id %a (%a)\n%!" typ_name.txt + Logger.fmt (Fun.flip Ident.print_with_scope typ_id) + Logger.fmt (fun fmt -> Location.print_loc fmt typ_name.loc); + register_uid uid typ_name; + () + | _ -> ()); + iter_decl.expr sub expr); + } + +let build_uid_to_locs_tbl ~(local_defs : Mtyper.typedtree) () = + let uid_to_locs_tbl : string Location.loc Types.Uid.Tbl.t = + Types.Uid.Tbl.create 64 + in + let iter = iter_on_defs ~uid_to_locs_tbl in + begin match local_defs with + | `Interface sign -> + iter.signature iter sign + | `Implementation str -> + iter.structure iter str end; + uid_to_locs_tbl + +let iter_on_usages ~f (local_defs : Mtyper.typedtree) = + let iter = Cmt_format.iter_on_occurrences ~f in + begin match local_defs with + | `Interface signature -> iter.signature iter signature + | `Implementation structure -> iter.structure iter structure end diff --git a/src/analysis/browse_tree.ml b/src/analysis/browse_tree.ml index 2f5b78b22b..65f205b544 100644 --- a/src/analysis/browse_tree.ml +++ b/src/analysis/browse_tree.ml @@ -60,87 +60,6 @@ let dummy = { t_children = lazy [] } -let rec normalize_type_expr env type_expr = - match Types.get_desc type_expr with - | Types.Tconstr (path,_,_) -> - normalize_type_decl env (Env.find_type path env) - | _ -> raise Not_found - -and normalize_type_decl env decl = match decl.Types.type_manifest with - | Some expr -> normalize_type_expr env expr - | None -> decl - -let id_of_constr_decl c = `Id c.Types.cd_id - -let same_constructor env a b = - let name = function - | `Description d -> d.Types.cstr_name - | `Declaration d -> Ident.name d.Typedtree.cd_id - | `Extension_constructor ec -> Ident.name ec.Typedtree.ext_id - in - if name a <> name b then false - else begin - let get_decls = function - | `Description d -> - let ty = normalize_type_expr env d.Types.cstr_res in - begin match ty.Types.type_kind with - | Types.Type_variant (decls, _) -> - List.map decls ~f:id_of_constr_decl - | Type_open -> - [`Uid d.cstr_uid] - | _ -> assert false - end - | `Declaration d -> - [`Id d.Typedtree.cd_id] - | `Extension_constructor ext_cons -> - let des = Env.find_ident_constructor ext_cons.Typedtree.ext_id env in - [`Uid des.cstr_uid] - in - let a = get_decls a in - let b = get_decls b in - let same a b = match a, b with - | `Id a, `Id b -> Ident.same a b - | `Uid a, `Uid b -> Shape.Uid.equal a b - | _, _ -> false - in - List.exists a ~f:(fun id -> List.exists b ~f:(same id)) - end - -let all_occurrences path = - let rec aux acc t = - let acc = - let paths = Browse_raw.node_paths t.t_node in - let same l = Path.same path l.Location.txt in - match List.filter ~f:same paths with - | [] -> acc - | paths -> (t, paths) :: acc - in - if Browse_raw.has_attr ~name:"merlin.hide" t.t_node then - acc - else - List.fold_left ~f:aux ~init:acc (Lazy.force t.t_children) - in - aux [] - -let all_constructor_occurrences ({t_env = env; _},d) t = - let rec aux acc t = - let acc = - match Browse_raw.node_is_constructor t.t_node with - | Some d' when ( - (* Don't try this at home kids. *) - try same_constructor env d d'.Location.txt - with Not_found -> same_constructor t.t_env d d'.Location.txt - ) -> - {d' with Location.txt = t} :: acc - | _ -> acc - in - if Browse_raw.has_attr ~name:"merlin.hide" t.t_node then - acc - else - List.fold_left ~f:aux ~init:acc (Lazy.force t.t_children) - in - aux [] t - let all_occurrences_of_prefix path node = let rec path_prefix ~prefix path = Path.same prefix path || diff --git a/src/analysis/browse_tree.mli b/src/analysis/browse_tree.mli index 66713bba13..48c1c33d3c 100644 --- a/src/analysis/browse_tree.mli +++ b/src/analysis/browse_tree.mli @@ -45,12 +45,5 @@ val of_browse : Mbrowse.t -> t val dummy : t -val all_occurrences : Path.t -> t -> (t * Path.t Location.loc list) list -val all_constructor_occurrences : - t * [ `Description of Types.constructor_description - | `Declaration of Typedtree.constructor_declaration - | `Extension_constructor of Typedtree.extension_constructor ] - -> t -> t Location.loc list - val all_occurrences_of_prefix : Path.t -> Browse_raw.node -> (Path.t Location.loc * Longident.t) list diff --git a/src/analysis/completion.ml b/src/analysis/completion.ml index f8d713250b..f3d66c6831 100644 --- a/src/analysis/completion.ml +++ b/src/analysis/completion.ml @@ -219,8 +219,8 @@ let make_candidate ~get_doc ~attrs ~exact ~prefix_path name ?loc ?path ty = | Some p, Some loc -> let namespace = (* FIXME: that's just terrible *) match kind with - | `Value -> `Vals - | `Type -> `Type + | `Value -> Shape.Sig_component_kind.Value + | `Type -> Type | _ -> assert false in begin match get_doc (`Completion_entry (namespace, p, loc)) with @@ -280,7 +280,7 @@ let fold_sumtype_constructors ~env ~init ~f t = (Path.name path); begin match Env.find_type_descrs path env with | exception Not_found -> init - | Type_record _ | Type_abstract | Type_open -> init + | Type_record _ | Type_abstract _ | Type_open -> init | Type_variant (constrs, _) -> List.fold_right constrs ~init ~f end @@ -650,7 +650,9 @@ let branch_complete buffer ?get_doc ?target_type ?kinds ~keywords prefix = let lbls = Datarepr.labels_of_type p decl in let labels = List.map lbls ~f:(fun (_,lbl) -> try - let _, lbl_arg, lbl_res = Ctype.instance_label false lbl in + let _, lbl_arg, lbl_res = + Ctype.instance_label ~fixed:false lbl + in begin try Ctype.unify_var env ty lbl_res; with _ -> () diff --git a/src/analysis/completion.mli b/src/analysis/completion.mli index 8cc348526d..7d379295d3 100644 --- a/src/analysis/completion.mli +++ b/src/analysis/completion.mli @@ -52,7 +52,7 @@ val map_entry : ('a -> 'b) -> val branch_complete : Mconfig.t - -> ?get_doc:([> `Completion_entry of Namespaced_path.Namespace.t + -> ?get_doc:([> `Completion_entry of Env_lookup.Namespace.t * Path.t * Location.t ] -> [> `Found of string ]) -> ?target_type:Types.type_expr -> ?kinds:Compl.kind list diff --git a/src/analysis/construct.ml b/src/analysis/construct.ml index 5511c6a2b9..3af7fa7754 100644 --- a/src/analysis/construct.ml +++ b/src/analysis/construct.ml @@ -329,15 +329,23 @@ module Gen = struct in fun env label ty -> let open Asttypes in + let make_param arg_label pat = + { + Parsetree.pparam_loc = Location.none; + pparam_desc = Pparam_val (arg_label, None, pat) + + } + in + match label with | Labelled s | Optional s -> (* Pun for labelled arguments *) - Ast_helper.Pat.var ( Location.mknoloc s), s + make_param label (Ast_helper.Pat.var (Location.mknoloc s)), s | Nolabel -> begin match get_desc ty with | Tconstr (path, _, _) -> let name = uniq_name env (Path.last path) in - Ast_helper.Pat.var (Location.mknoloc name), name - | _ -> Ast_helper.Pat.any (), "_" end + make_param label (Ast_helper.Pat.var (Location.mknoloc name)), name + | _ -> make_param label (Ast_helper.Pat.any ()), "_" end in let constructor env type_expr path constrs = @@ -347,7 +355,10 @@ module Gen = struct (* [make_constr] builds the PAST repr of a type constructor applied to holes *) let make_constr env path type_expr cstr_descr = - let ty_args, ty_res, _ = Ctype.instance_constructor cstr_descr in + let ty_args, ty_res, _ = Ctype.instance_constructor + Keep_existentials_flexible + cstr_descr + in match Util.unifiable env type_expr ty_res with | Some snap -> let lid = @@ -422,7 +433,7 @@ module Gen = struct (List.map labels ~f:(fun l -> l.Types.lbl_name))); let labels = List.map labels ~f:(fun ({ lbl_name; _ } as lbl) -> - let _, arg, res = Ctype.instance_label true lbl in + let _, arg, res = Ctype.instance_label ~fixed:true lbl in Ctype.unify env res typ ; let lid = Util.maybe_prefix env @@ -474,21 +485,31 @@ module Gen = struct match def with | Type_variant (constrs, _) -> constructor env rtyp path constrs | Type_record (labels, _) -> record env rtyp path labels - | Type_abstract | Type_open -> [] + | Type_abstract _ | Type_open -> [] end - | Tarrow (label, tyleft, tyright, _) -> - let argument, name = make_arg env label tyleft in - let value_description = { - val_type = tyleft; - val_kind = Val_reg; - val_loc = Location.none; - val_attributes = []; - val_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); - } - in - let env = Env.add_value (Ident.create_local name) value_description env in - let exps = arrow_rhs env tyright in - List.map exps ~f:(Ast_helper.Exp.fun_ label None argument) + | Tarrow _ -> + let rec left_types acc env ty = + match get_desc ty with + | Tarrow (label, tyleft, tyright, _) -> + let arg, name = make_arg env label tyleft in + let value_description = { + val_type = tyleft; + val_kind = Val_reg; + val_loc = Location.none; + val_attributes = []; + val_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); + } + in + let env = + Env.add_value (Ident.create_local name) value_description env + in + left_types (arg :: acc) env tyright + | _ -> List.rev acc, ty, env + in + let arguments, body_type, env = left_types [] env rtyp in + let exps = arrow_rhs env body_type in + List.map exps ~f:(fun e -> + Ast_helper.Exp.function_ arguments None (Pfunction_body e)) | Ttuple types -> let choices = List.map types ~f:(exp_or_hole env) |> Util.combinations @@ -545,7 +566,7 @@ module Gen = struct end let needs_parentheses e = match e.Parsetree.pexp_desc with - | Pexp_fun _ + | Pexp_function _ | Pexp_lazy _ | Pexp_apply _ | Pexp_variant (_, Some _) diff --git a/src/analysis/context.ml b/src/analysis/context.ml index 7fba149868..ec8daab26a 100644 --- a/src/analysis/context.ml +++ b/src/analysis/context.ml @@ -87,9 +87,9 @@ let inspect_pattern (type a) ~cursor ~lid (p : a Typedtree.general_pattern) = (Printtyped.pattern 0) p); match p.pat_desc with | Tpat_any when Longident.last lid = "_" -> None - | Tpat_var (_, str_loc) when (Longident.last lid) = str_loc.txt -> + | Tpat_var (_, str_loc, _) when (Longident.last lid) = str_loc.txt -> None - | Tpat_alias (_, _, str_loc) + | Tpat_alias (_, _, str_loc, _) when (Longident.last lid) = str_loc.txt -> (* Assumption: if [Browse.enclosing] stopped on this node and not on the subpattern, then it must mean that the cursor is on the alias. *) diff --git a/src/analysis/destruct.ml b/src/analysis/destruct.ml index 740e281a8e..17758f42ab 100644 --- a/src/analysis/destruct.ml +++ b/src/analysis/destruct.ml @@ -105,7 +105,9 @@ let rec gen_patterns ?(recurse=true) env type_expr = List.map labels ~f:(fun lbl_descr -> let lidloc = mk_id lbl_descr.lbl_name in lidloc, lbl_descr, - Tast_helper.Pat.var env type_expr (mk_var lbl_descr.lbl_name) + Tast_helper.Pat.var + (Uid.internal_not_actually_unique) + env type_expr (mk_var lbl_descr.lbl_name) ) in [ Tast_helper.Pat.record env type_expr lst Asttypes.Closed ] @@ -121,9 +123,11 @@ let rec gen_patterns ?(recurse=true) env type_expr = let res = try ignore ( - Ctype.unify_gadt ~equations_level:0 - ~allow_recursive:true (* really? *) - (ref env) type_expr typ + let pattern_env = Ctype.Pattern_env.make env + ~equations_scope:0 + ~allow_recursive_equations:true + in + Ctype.unify_gadt pattern_env type_expr typ ); true with Ctype.Unify _trace -> false @@ -199,7 +203,7 @@ let rec needs_parentheses = function | Texp_let _ (* We are after the "in" keyword, we need to look at the parent of the binding. *) - | Texp_function {cases = [ _ ]; _ } + | Texp_function (_, Tfunction_body _) (* The assumption here is that we're not in a [function ... | ...] situation but either in [fun param] or [let name param]. *) -> @@ -278,17 +282,39 @@ let collect_every_pattern_for_expression parent = ) Env.empty parent Location.none in loc, patterns -let rec get_every_pattern = function +let collect_function_pattern loc param_pattern = + match param_pattern.Typedtree.fp_kind with + | Typedtree.Tparam_pat pattern -> + loc, [pattern] + | Typedtree.Tparam_optional_default _ -> + raise (Not_allowed "value_binding") + +let rec get_every_pattern loc = function | [] -> assert false | parent :: parents -> match parent with | Case _ | Pattern _ -> (* We are still in the same branch, going up. *) - get_every_pattern parents + get_every_pattern loc parents | Expression { exp_desc = Typedtree.Texp_ident (Path.Pident id, _, _) ; _} when Ident.name id = "*type-error*" -> raise (Ill_typed) + | Expression { exp_desc = Typedtree.Texp_function (params, _body); _ } -> + (* So we need to deal with the case where we're either in the body of a + function, or in a function parameter. *) + begin + match + List.find_some ~f:(fun param -> + Location_aux.included ~into:param.Typedtree.fp_loc loc + ) params with + | Some pattern -> + (* In parameter case *) + collect_function_pattern loc pattern + | None -> + (* In function body *) + collect_every_pattern_for_expression parent + end | Expression _ -> (* We are on the right node *) collect_every_pattern_for_expression parent @@ -301,7 +327,7 @@ let rec destructible patt = let open Typedtree in match patt.pat_desc with | Tpat_any | Tpat_var _ -> true - | Tpat_alias (p, _, _) -> destructible p + | Tpat_alias (p, _, _, _) -> destructible p | _ -> false @@ -335,8 +361,8 @@ let rec subst_patt initial ~by patt = | Tpat_any | Tpat_var _ | Tpat_constant _ -> patt - | Tpat_alias (p,x,y) -> - { patt with pat_desc = Tpat_alias (f p, x, y) } + | Tpat_alias (p,x,y,uid) -> + { patt with pat_desc = Tpat_alias (f p, x, y,uid) } | Tpat_tuple lst -> { patt with pat_desc = Tpat_tuple (List.map lst ~f) } | Tpat_construct (lid, cd, lst, lco) -> @@ -362,8 +388,8 @@ let rec rm_sub patt sub = | Tpat_any | Tpat_var _ | Tpat_constant _ -> patt - | Tpat_alias (p,x,y) -> - { patt with pat_desc = Tpat_alias (f p, x, y) } + | Tpat_alias (p,x,y,uid) -> + { patt with pat_desc = Tpat_alias (f p, x, y,uid) } | Tpat_tuple lst -> { patt with pat_desc = Tpat_tuple (List.map lst ~f) } | Tpat_construct (lid, cd, lst, lco) -> @@ -388,7 +414,8 @@ let rec qualify_constructors ~unmangling_tables f pat = let qualify_constructors = qualify_constructors ~unmangling_tables in let pat_desc = match pat.pat_desc with - | Tpat_alias (p, id, loc) -> Tpat_alias (qualify_constructors f p, id, loc) + | Tpat_alias (p, id, loc, uid) -> + Tpat_alias (qualify_constructors f p, id, loc, uid) | Tpat_tuple ps -> Tpat_tuple (List.map ps ~f:(qualify_constructors f)) | Tpat_record (labels, closed) -> let labels = @@ -398,16 +425,14 @@ let rec qualify_constructors ~unmangling_tables f pat = let lid_name = flatten txt |> String.concat ~sep:"." in let pat = qualify_constructors f pat in (* Un-mangle *) - match unmangling_tables with - | Some (_, labels) -> + let (_, labels) = unmangling_tables in (match Hashtbl.find_opt labels lid_name with | Some lbl_des -> ( { lid with txt = Lident lbl_des.Types.lbl_name }, lbl_des, pat ) - | None -> (lid, lbl_des, pat)) - | None -> (lid, lbl_des, pat)) + | None -> (lid, lbl_des, pat))) in let closed = if List.length labels > 0 then @@ -423,12 +448,11 @@ let rec qualify_constructors ~unmangling_tables f pat = match lid.Asttypes.txt with | Longident.Lident name -> (* Un-mangle *) - let name = match unmangling_tables with - | Some (constrs, _) -> + let name = + let constrs, _ = unmangling_tables in (match Hashtbl.find_opt constrs name with | Some cstr_des -> cstr_des.Types.cstr_name | None -> name) - | None -> name in begin match Types.get_desc pat.pat_type with | Types.Tconstr (path, _, _) -> @@ -461,7 +485,7 @@ let find_branch patterns sub = | Tpat_var _ | Tpat_constant _ | Tpat_variant (_, None, _) -> false - | Tpat_alias (p,_,_) + | Tpat_alias (p,_,_,_) | Tpat_variant (_, Some p, _) | Tpat_lazy p -> is_sub_patt p ~sub @@ -475,7 +499,7 @@ let find_branch patterns sub = is_sub_patt p1 ~sub || is_sub_patt p2 ~sub in let rec aux before = function - | [] -> raise Not_found + | [] -> raise Nothing_to_do | p :: after when is_sub_patt p ~sub -> before, after, p | p :: ps -> aux (p :: before) ps in @@ -500,6 +524,70 @@ let print_pretty ?punned_field config source subject = | Some label -> label.Types.lbl_name ^ " = " ^ result +(* conversion from Typedtree.pattern to Parsetree.pattern list *) +module Conv = struct + open Asttypes + open Types + open Typedtree + open Parsetree + let mkpat desc = Ast_helper.Pat.mk desc + + let name_counter = ref 0 + let fresh name = + let current = !name_counter in + name_counter := !name_counter + 1; + "#$" ^ name ^ Int.to_string current + + let conv typed = + let constrs = Hashtbl.create 7 in + let labels = Hashtbl.create 7 in + let rec loop pat = + match pat.pat_desc with + Tpat_or (pa,pb,_) -> + mkpat (Ppat_or (loop pa, loop pb)) + | Tpat_var (_, ({txt="*extension*"; _} as nm), _) -> (* PR#7330 *) + mkpat (Ppat_var nm) + | Tpat_any + | Tpat_var _ -> + mkpat Ppat_any + | Tpat_constant c -> + mkpat (Ppat_constant (Untypeast.constant c)) + | Tpat_alias (p,_,_,_) -> loop p + | Tpat_tuple lst -> + mkpat (Ppat_tuple (List.map ~f:loop lst)) + | Tpat_construct (cstr_lid, cstr, lst, _) -> + let id = fresh cstr.cstr_name in + let lid = { cstr_lid with txt = Longident.Lident id } in + Hashtbl.add constrs id cstr; + let arg = + match List.map ~f:loop lst with + | [] -> None + | [p] -> Some ([], p) + | lst -> Some ([], mkpat (Ppat_tuple lst)) + in + mkpat (Ppat_construct(lid, arg)) + | Tpat_variant(label,p_opt,_row_desc) -> + let arg = Option.map ~f:loop p_opt in + mkpat (Ppat_variant(label, arg)) + | Tpat_record (subpatterns, _closed_flag) -> + let fields = + List.map + ~f:(fun (_, lbl, p) -> + let id = fresh lbl.lbl_name in + Hashtbl.add labels id lbl; + (mknoloc (Longident.Lident id), loop p)) + subpatterns + in + mkpat (Ppat_record (fields, Open)) + | Tpat_array lst -> + mkpat (Ppat_array (List.map ~f:loop lst)) + | Tpat_lazy p -> + mkpat (Ppat_lazy (loop p)) + in + let ps = loop typed in + (ps, constrs, labels) +end + let destruct_expression loc config source parents expr = let ty = expr.Typedtree.exp_type in let pexp = filter_expr_attr (Untypeast.untype_expression expr) in @@ -523,12 +611,12 @@ let destruct_expression loc config source parents expr = let str = if needs_parentheses then "(" ^ str ^ ")" else str in loc, str - let refine_partial_match last_case_loc config source patterns = - let cases = List.map patterns ~f:(fun (pat, unmangling_tables) -> + let cases = List.map patterns ~f:(fun pat -> + let _pat, constrs, labels = Conv.conv pat in + let unmangling_tables = constrs, labels in (* Unmangling and prefixing *) - let pat = - qualify_constructors ~unmangling_tables Printtyp.shorten_type_path pat in + let pat = qualify_constructors ~unmangling_tables Printtyp.shorten_type_path pat in (* Untyping and casing *) let ppat = filter_pat_attr (Untypeast.untype_pattern pat) in Ast_helper.Exp.case ppat placeholder @@ -547,14 +635,13 @@ let filter_new_branches new_branches patterns = if branch != p then branch else List.fold_left lst ~init:branch ~f:rm_sub)) -let refine_current_pattern patt config source parents generated_pattern = +let refine_current_pattern parents patt config source generated_pattern = let punned_field = find_field_name_for_punned_field patt parents in let ppat = filter_pat_attr (Untypeast.untype_pattern generated_pattern) in let str = print_pretty ?punned_field config source (Pretty_pattern ppat) in patt.Typedtree.pat_loc, str -let refine_and_generate_branches patt config source - (patterns : Typedtree.pattern list) sub_patterns = +let refine_and_generate_branches patt config source patterns sub_patterns = let rev_before, after, top_patt = find_branch patterns patt in let new_branches = List.map sub_patterns ~f:(fun by -> subst_patt patt ~by top_patt) @@ -576,8 +663,8 @@ let refine_and_generate_branches patt config source top_patt.Typedtree.pat_loc, str let refine_complete_match - (type a) (patt: a Typedtree.general_pattern) - config source parents patterns = + (type a) parents (patt: a Typedtree.general_pattern) + config source patterns = match Typedtree.classify_pattern patt with | Computation -> raise (Not_allowed ("computation pattern")) | Value -> @@ -590,7 +677,7 @@ let refine_complete_match | [more_precise_pattern] -> (* If only one pattern is generated, then we're only refining the current pattern, not generating new branches. *) - refine_current_pattern patt config source parents more_precise_pattern + refine_current_pattern parents patt config source more_precise_pattern | sub_patterns -> (* If more than one pattern is generated, then we're generating new branches. *) @@ -599,8 +686,8 @@ let refine_complete_match let destruct_pattern (type a) (patt: a Typedtree.general_pattern) - config source parents = - let last_case_loc, patterns = get_every_pattern parents in + config source loc parents = + let last_case_loc, patterns = get_every_pattern loc parents in (* Printf.eprintf "tot %d o%!"(List.length patterns); *) let () = List.iter patterns ~f:(fun p -> let p = filter_pat_attr (Untypeast.untype_pattern p) in @@ -609,16 +696,11 @@ let destruct_pattern in let pss = List.map patterns ~f:(fun x -> [ x ]) in let m, e_typ = get_match parents in - let pred = - Typecore.partial_pred - ~lev:Btype.generic_level - m.Typedtree.exp_env - e_typ - in + let pred = Typecore.partial_pred ~lev:Btype.generic_level m.Typedtree.exp_env e_typ in match Parmatch.complete_partial ~pred pss with | [] -> (* The match is already complete, we try to refine it *) - refine_complete_match patt config source parents patterns + refine_complete_match parents patt config source patterns | patterns -> refine_partial_match last_case_loc config source patterns @@ -637,7 +719,6 @@ and node config source selected_node parents = destruct_record config source selected_node parents | Expression expr -> destruct_expression loc config source parents expr - | Pattern patt -> - destruct_pattern patt config source parents + | Pattern patt -> destruct_pattern patt config source loc parents | node -> raise (Not_allowed (string_of_node node)) diff --git a/src/analysis/dune b/src/analysis/dune index 1521f351e9..6b4d2f6d09 100644 --- a/src/analysis/dune +++ b/src/analysis/dune @@ -21,4 +21,5 @@ ocaml_preprocess query_protocol ocaml_typing - ocaml_utils)) + ocaml_utils + str)) diff --git a/src/analysis/env_lookup.ml b/src/analysis/env_lookup.ml new file mode 100644 index 0000000000..929ee982b5 --- /dev/null +++ b/src/analysis/env_lookup.ml @@ -0,0 +1,158 @@ +open! Std +let {Logger. log} = Logger.for_section "env-lookup" + +module Namespace = struct + type t = Shape.Sig_component_kind.t + + let to_string = Shape.Sig_component_kind.to_string + + type under_type = [ `Constr | `Labels ] + + type inferred_basic = (* TODO: share with [Namespace.t] *) + [ `Type | `Mod | `Modtype | `Vals | under_type ] + + type inferred = + [ inferred_basic + | `This_label of Types.label_description + | `This_cstr of Types.constructor_description ] + + let from_context : Context.t -> inferred list = function + | Type -> [ `Type ; `Mod ; `Modtype ; `Constr ; `Labels ; `Vals ] + | Module_type -> [ `Modtype ; `Mod ; `Type ; `Constr ; `Labels ; `Vals ] + | Expr | Constant -> + [ `Vals ; `Mod ; `Modtype ; `Constr ; `Labels ; `Type ] + | Patt -> [ `Mod ; `Modtype ; `Type ; `Constr ; `Labels ; `Vals ] + | Unknown -> [ `Vals ; `Type ; `Constr ; `Mod ; `Modtype ; `Labels ] + | Label lbl -> [ `This_label lbl ] + | Module_path -> [ `Mod ] + | Constructor (c, _) -> [ `This_cstr c ] +end + +type item = { + uid: Shape.Uid.t; + loc: Location.t; + namespace: Shape.Sig_component_kind.t +} + +let by_path path (namespace : Namespace.t) env = + try + let loc, uid, (namespace : Namespace.t) = + match namespace with + | Value -> + let vd = Env.find_value path env in + vd.val_loc, vd.val_uid, Value + | (Type | Extension_constructor | Constructor | Label) -> + let td = Env.find_type path env in + td.type_loc, td.type_uid, Type + | Module -> + let md = Env.find_module path env in + md.md_loc, md.md_uid, Module + | Module_type -> + let mtd = Env.find_modtype path env in + mtd.mtd_loc, mtd.mtd_uid, Module_type + | Class -> + let cty = Env.find_class path env in + cty.cty_loc, cty.cty_uid, Class + | Class_type -> + let clty = Env.find_cltype path env in + clty.clty_loc, clty.clty_uid, Class + in + Some { uid; loc; namespace } + with + Not_found -> None + +exception Found of + (Path.t * Shape.Sig_component_kind.t * Shape.Uid.t * Location.t) + +let path_and_loc_of_cstr desc _ = + let open Types in + match desc.cstr_tag with + | Cstr_extension (path, _) -> path, desc.cstr_loc + | _ -> + match get_desc desc.cstr_res with + | Tconstr (path, _, _) -> path, desc.cstr_loc + | _ -> assert false + +let path_and_loc_from_label desc env = + let open Types in + match get_desc desc.lbl_res with + | Tconstr (path, _, _) -> + let typ_decl = Env.find_type path env in + path, typ_decl.Types.type_loc + | _ -> assert false + +let by_longident (nss : Namespace.inferred list) ident env = + let open Shape.Sig_component_kind in + try + List.iter nss ~f:(fun namespace -> + try + match namespace with + | `This_cstr ({ Types.cstr_tag = Cstr_extension _; _ } as cd) -> + log ~title:"lookup" + "got extension constructor"; + let path, loc = path_and_loc_of_cstr cd env in + (* TODO: Use [`Constr] here instead of [`Type] *) + raise (Found (path, Extension_constructor, cd.cstr_uid, loc)) + | `This_cstr cd -> + log ~title:"lookup" + "got constructor, fetching path and loc in type namespace"; + let path, loc = path_and_loc_of_cstr cd env in + log ~title:"lookup" "found path: %a" + Logger.fmt (fun fmt -> Path.print fmt path); + let path = Path.Pdot (path, cd.cstr_name) + in + raise (Found (path, Constructor, cd.cstr_uid, loc)) + | `Constr -> + log ~title:"lookup" "lookup in constructor namespace" ; + let cd = Env.find_constructor_by_name ident env in + let path, loc = path_and_loc_of_cstr cd env in + let path = Path.Pdot (path, cd.cstr_name) in + (* TODO: Use [`Constr] here instead of [`Type] *) + raise (Found (path, Constructor,cd.cstr_uid, loc)) + | `Mod -> + log ~title:"lookup" "lookup in module namespace" ; + let path, md = Env.find_module_by_name ident env in + raise (Found (path, Module, md.md_uid, md.Types.md_loc)) + | `Modtype -> + log ~title:"lookup" "lookup in module type namespace" ; + let path, mtd = Env.find_modtype_by_name ident env in + raise + (Found (path, Module_type, mtd.mtd_uid, mtd.Types.mtd_loc)) + | `Type -> + log ~title:"lookup" "lookup in type namespace" ; + let path, typ_decl = Env.find_type_by_name ident env in + raise ( + Found + (path, Type, typ_decl.type_uid, typ_decl.Types.type_loc) + ) + | `Vals -> + log ~title:"lookup" "lookup in value namespace" ; + let path, val_desc = Env.find_value_by_name ident env in + raise ( + Found + (path, Value, val_desc.val_uid, val_desc.Types.val_loc) + ) + | `This_label lbl -> + log ~title:"lookup" + "got label, fetching path and loc in type namespace"; + let path, loc = path_and_loc_from_label lbl env in + let path = Path.Pdot (path, lbl.lbl_name) + in + raise (Found (path, Label, lbl.lbl_uid, loc)) + | `Labels -> + log ~title:"lookup" "lookup in label namespace" ; + let lbl = Env.find_label_by_name ident env in + let path, loc = path_and_loc_from_label lbl env in + (* TODO: Use [`Labels] here instead of [`Type] *) + raise (Found (path, Type, lbl.lbl_uid, loc)) + with Not_found -> () + ) ; + log ~title:"lookup" " ... not in the environment" ; + None + with Found (path, namespace, decl_uid, loc) -> + log ~title:"env_lookup" "found: '%a' in namespace %s with decl_uid %a\nat loc %a" + Logger.fmt (fun fmt -> Path.print fmt path) + (Shape.Sig_component_kind.to_string namespace) + Logger.fmt (fun fmt -> Shape.Uid.print fmt decl_uid) + Logger.fmt (fun fmt -> Location.print_loc fmt loc); + Some (path, { uid = decl_uid; loc; namespace }) diff --git a/src/analysis/env_lookup.mli b/src/analysis/env_lookup.mli new file mode 100644 index 0000000000..cca3499e58 --- /dev/null +++ b/src/analysis/env_lookup.mli @@ -0,0 +1,48 @@ +(** Provides tools to lookup items in the typing environment. + + Establishing the namespace of an item before looking it up in the environement + is necessary to prevent mixing items which have the same name but are not of + the same namespace. (For example the environment can contain both type named + `t` and a value named `t`.) *) + +(** Namespaces describe in which section of the environment an item should be + looked for. *) +module Namespace : sig + type t = Shape.Sig_component_kind.t + + val to_string : t -> string + + type under_type = [ `Constr | `Labels ] + type inferred_basic = + [ `Constr | `Labels | `Mod | `Modtype | `Type | `Vals ] + type inferred = + [ `Constr + | `Labels + | `Mod + | `Modtype + | `This_cstr of Types.constructor_description + | `This_label of Types.label_description + | `Type + | `Vals ] + + (** Returns potential namespaces given the context of an expression *) + val from_context : Context.t -> inferred list +end + +type item = { + uid: Shape.Uid.t; + loc: Location.t; + namespace: Namespace.t +} + +val by_path + : Path.t + -> Namespace.t + -> Env.t + -> item option + +val by_longident + : Namespace.inferred list + -> Longident.t + -> Env.t + -> (Path.t * item) option diff --git a/src/analysis/index_format.ml b/src/analysis/index_format.ml new file mode 100644 index 0000000000..12957f1d9d --- /dev/null +++ b/src/analysis/index_format.ml @@ -0,0 +1,23 @@ +module Lid : Set.OrderedType with type t = Longident.t Location.loc = struct + type t = Longident.t Location.loc + + let compare_pos (p1 : Lexing.position) (p2 : Lexing.position) = + match String.compare p1.pos_fname p2.pos_fname with + | 0 -> Int.compare p1.pos_cnum p2.pos_cnum + | n -> n + + let compare (t1 : t) (t2 : t) = + match compare_pos t1.loc.loc_start t2.loc.loc_start with + | 0 -> compare_pos t1.loc.loc_end t2.loc.loc_end + | n -> n +end + +module LidSet = Set.Make (Lid) + +(** [add tbl uid locs] adds a binding of [uid] to the locations [locs]. If this key is + already present the locations are merged. *) + let add tbl uid locs = + try + let locations = Hashtbl.find tbl uid in + Hashtbl.replace tbl uid (LidSet.union locs locations) + with Not_found -> Hashtbl.add tbl uid locs diff --git a/src/analysis/locate.ml b/src/analysis/locate.ml index 44236c0df5..f7a9fba6f7 100644 --- a/src/analysis/locate.ml +++ b/src/analysis/locate.ml @@ -31,6 +31,21 @@ open Std let last_location = ref Location.none let {Logger. log} = Logger.for_section "locate" + +type config = { + mconfig: Mconfig.t; + ml_or_mli: [ `ML | `MLI ]; + traverse_aliases: bool; +} + +type result = { + uid: Shape.Uid.t; + decl_uid: Shape.Uid.t; + file: string; + location: Location.t; + approximated: bool; +} + module File : sig type t = private | ML of string @@ -194,10 +209,6 @@ end module Utils = struct - let is_builtin_path = function - | Path.Pident id -> Ident.is_predef id - | _ -> false - (* Reuse the code of [Misc.find_in_path_uncap] but returns all the files matching, instead of the first one. This is only used when looking for ml files, not cmts. Indeed for cmts we know that the load path will only ever @@ -208,6 +219,8 @@ module Utils = struct Note: We do not refine the load path for module path as we used too. *) let find_all_in_path_uncap ?src_suffix_pair ~with_fallback path file = let name = File.with_ext ?src_suffix_pair file in + log ~title:"find_all_in_path_uncap" "Looking for file %S in path:\n%a" name + Logger.fmt (fun fmt -> Format.pp_print_list Format.pp_print_string fmt path); let uname = String.uncapitalize name in let fallback, ufallback = let alt = File.alternate file in @@ -255,7 +268,7 @@ module Utils = struct None in let fname = File.with_ext ~src_suffix_pair file in - try Some (Misc.find_in_path_uncap ?fallback path fname) + try Some (Misc.find_in_path_normalized ?fallback path fname) with Not_found -> None in try @@ -267,7 +280,7 @@ module Utils = struct find_file_with_path ~config ?with_fallback file @@ match file with | ML _ | MLI _ | MLL _ -> Mconfig.source_path config - | CMT _ | CMTI _ -> Mconfig.build_path config + | CMT _ | CMTI _ -> Mconfig.cmt_path config end let move_to filename cmt_infos = @@ -297,13 +310,12 @@ let move_to filename cmt_infos = in File_switching.move_to ~digest filename - -let load_cmt ~config comp_unit ml_or_mli = - Preferences.set ml_or_mli; +let load_cmt ~config ?(with_fallback = true) comp_unit = + Preferences.set config.ml_or_mli; let file = Preferences.build comp_unit in - match Utils.find_file ~config ~with_fallback:true file with + match Utils.find_file ~config:config.mconfig ~with_fallback file with | Some path -> let cmt_infos = (Cmt_cache.read path).cmt_infos in let source_file = cmt_infos.cmt_sourcefile in @@ -339,125 +351,6 @@ let scrape_alias ~env ~fallback_uid ~namespace path = in non_alias_declaration_uid ~fallback_uid path -let uid_of_path ~config ~env ~ml_or_mli ~decl_uid path namespace = - let module Shape_reduce = - Shape.Make_reduce (struct - type env = Env.t - - let fuel = 10 - - let read_unit_shape ~unit_name = - log ~title:"read_unit_shape" "inspecting %s" unit_name; - match load_cmt ~config unit_name `ML with - | Ok (filename, cmt_infos) -> - move_to filename cmt_infos; - log ~title:"read_unit_shape" "shapes loaded for %s" unit_name; - cmt_infos.cmt_impl_shape - | Error () -> - log ~title:"read_unit_shape" "failed to find %s" unit_name; - None - - let find_shape env id = Env.shape_of_path - ~namespace:Shape.Sig_component_kind.Module env (Pident id) - end) - in - let unalias fallback_uid = - let uid = scrape_alias ~fallback_uid ~env ~namespace path in - log ~title:"uid_of_path" "Unaliasing uid: %a -> %a" - Logger.fmt (fun fmt -> Shape.Uid.print fmt fallback_uid) - Logger.fmt (fun fmt -> Shape.Uid.print fmt uid); - uid - in - match ml_or_mli with - | `MLI -> unalias decl_uid - | `ML -> - let shape = Env.shape_of_path ~namespace env path in - log ~title:"shape_of_path" "initial: %a" - Logger.fmt (fun fmt -> Shape.print fmt shape); - let r = Shape_reduce.weak_reduce env shape in - log ~title:"shape_of_path" "reduced: %a" - Logger.fmt (fun fmt -> Shape.print fmt r); - match r.uid with - | Some uid -> uid - | None -> - log ~title:"shape_of_path" "No uid found; fallbacking to declaration uid"; - unalias decl_uid - -let from_uid ~config ~ml_or_mli uid loc path = - let loc_of_comp_unit comp_unit = - match load_cmt ~config comp_unit ml_or_mli with - | Ok (pos_fname, _cmt) -> - let pos = Std.Lexing.make_pos ~pos_fname (1, 0) in - let loc = { Location.loc_start=pos; loc_end=pos; loc_ghost=true } in - Some loc - | _ -> None - in - let title = "from_uid" in - match uid with - | Shape.Uid.Item { comp_unit; _ } -> - let locopt = - let log_and_return msg = log ~title msg; None in - let uid_to_loc_tbl = - if Env.get_unit_name () = comp_unit then begin - log ~title "We look for %a in the current compilation unit." - Logger.fmt (fun fmt -> Shape.Uid.print fmt uid); - Some (Env.get_uid_to_loc_tbl ()) - end else begin - log ~title "Loading the cmt for unit %S" comp_unit; - match load_cmt ~config comp_unit ml_or_mli with - | Ok (_pos_fname, cmt) -> Some cmt.cmt_uid_to_loc - | Error () -> log_and_return "Failed to load the cmt file." - end - in - Option.bind uid_to_loc_tbl ~f:(fun tbl -> - log ~title "Looking for %a in the uid_to_loc table" - Logger.fmt (fun fmt -> Shape.Uid.print fmt uid); - match Shape.Uid.Tbl.find_opt tbl uid with - | Some loc -> - log ~title "Found location: %a" - Logger.fmt (fun fmt -> Location.print_loc fmt loc); - Some (uid, loc) - | None -> log_and_return "Uid not found in the table.") - in - begin match locopt with - | Some (uid, loc) -> `Found (Some uid, loc) - | None -> - log ~title "Fallbacking to lookup location: %a" - Logger.fmt (fun fmt -> Location.print_loc fmt loc); - `Found (Some uid, loc) - end - | Compilation_unit comp_unit -> - begin - log ~title "Got the uid of a compilation unit: %a" - Logger.fmt (fun fmt -> Shape.Uid.print fmt uid); - match loc_of_comp_unit comp_unit with - | Some loc -> `Found (Some uid, loc) - | _ -> log ~title "Failed to load the CU's cmt"; - `Not_found (Path.name path, None) - end - | Predef _ | Internal -> assert false - -let locate ~config ~env ~ml_or_mli decl_uid loc path ns = - let uid = uid_of_path ~config ~env ~ml_or_mli ~decl_uid path ns in - from_uid ~config ~ml_or_mli uid loc path - -let path_and_loc_of_cstr desc _ = - let open Types in - match desc.cstr_tag with - | Cstr_extension (path, _) -> path, desc.cstr_loc - | _ -> - match get_desc desc.cstr_res with - | Tconstr (path, _, _) -> path, desc.cstr_loc - | _ -> assert false - -let path_and_loc_from_label desc env = - let open Types in - match get_desc desc.lbl_res with - | Tconstr (path, _, _) -> - let typ_decl = Env.find_type path env in - path, typ_decl.Types.type_loc - | _ -> assert false - type find_source_result = | Found of string | Not_found of File.t @@ -481,9 +374,10 @@ let find_source ~config loc = | None -> fname | Some s -> s in + log ~title:"find_source" "initial path: %S" initial_path; let dir = Filename.dirname initial_path in let dir = - match Mconfig.(config.query.directory) with + match config.Mconfig.query.directory with | "" -> dir | cwd -> Misc.canonicalize_filename ~cwd dir in @@ -492,7 +386,9 @@ let find_source ~config loc = log ~title:"find_source" "failed to find %S in source path (fallback = %b)" filename with_fallback ; log ~title:"find_source" "looking for %S in %S" (File.name file) dir ; - begin match Utils.find_file_with_path ~config ~with_fallback file [dir] with + begin match + Utils.find_file_with_path ~config ~with_fallback file [dir] + with | Some source -> Found source | None -> log ~title:"find_source" "Trying to find %S in %S directly" fname dir; @@ -585,8 +481,8 @@ let find_source ~config loc path = | _ -> failure | exception _ -> failure in - match result with - | Found src -> `Found (Some src, loc.Location.loc_start) + match (result : find_source_result) with + | Found src -> `Found (src, loc) | Not_found f -> File.explain_not_found path f | Multiple_matches lst -> let matches = String.concat lst ~sep:", " in @@ -595,181 +491,176 @@ let find_source ~config loc path = merlin doesn't know which is the right one: %s" matches) -module Namespace = struct - type under_type = [ `Constr | `Labels ] - - type t = (* TODO: share with [Namespaced_path.Namespace.t] *) - [ `Type | `Mod | `Modtype | `Vals | under_type ] - - type inferred = - [ t - | `This_label of Types.label_description - | `This_cstr of Types.constructor_description ] - - let from_context : Context.t -> inferred list = function - | Type -> [ `Type ; `Mod ; `Modtype ; `Constr ; `Labels ; `Vals ] - | Module_type -> [ `Modtype ; `Mod ; `Type ; `Constr ; `Labels ; `Vals ] - | Expr | Constant -> - [ `Vals ; `Mod ; `Modtype ; `Constr ; `Labels ; `Type ] - | Patt -> [ `Mod ; `Modtype ; `Type ; `Constr ; `Labels ; `Vals ] - | Unknown -> [ `Vals ; `Type ; `Constr ; `Mod ; `Modtype ; `Labels ] - | Label lbl -> [ `This_label lbl ] - | Module_path -> [ `Mod ] - | Constructor (c, _) -> [ `This_cstr c ] -end - -module Env_lookup : sig - - val loc - : Path.t - -> Namespaced_path.Namespace.t - -> Env.t - -> (Location.t * Shape.Uid.t * Shape.Sig_component_kind.t) option - - val in_namespaces - : Namespace.inferred list - -> Longident.t - -> Env.t - -> (Path.t * Shape.Sig_component_kind.t * Shape.Uid.t * Location.t) option - -end = struct - - let loc path (namespace : Namespaced_path.Namespace.t) env = - try - Some ( - match namespace with - | `Unknown - | `Apply - | `Vals -> - let vd = Env.find_value path env in - vd.val_loc, vd.val_uid, Shape.Sig_component_kind.Value - | `Constr - | `Labels - | `Type -> - let td = Env.find_type path env in - td.type_loc, td.type_uid, Shape.Sig_component_kind.Type - | `Functor - | `Mod -> - let md = Env.find_module path env in - md.md_loc, md.md_uid, Shape.Sig_component_kind.Module - | `Modtype -> - let mtd = Env.find_modtype path env in - mtd.mtd_loc, mtd.mtd_uid, Shape.Sig_component_kind.Module_type - ) - with - Not_found -> None - - exception Found of - (Path.t * Shape.Sig_component_kind.t * Shape.Uid.t * Location.t) +(** [find_loc_of_uid] uid's location are given by tables stored int he cmt files + for external compilation units or computed by Merlin for the current buffer. + This function lookups a uid's location in the appropriate table. *) +let find_loc_of_uid ~config ~local_defs uid comp_unit = + let title = "find_loc_of_uid" in + let loc_of_decl ~uid def = + match Misc_utils.loc_of_decl ~uid def with + | Some loc -> + log ~title "Found location: %a" + Logger.fmt (fun fmt -> Location.print_loc fmt loc.loc); + `Some (uid, loc.loc) + | None -> log ~title "The declaration has no location."; `None + in + if Env.get_unit_name () = comp_unit then begin + log ~title "We look for %a in the current compilation unit." + Logger.fmt (fun fmt -> Shape.Uid.print fmt uid); + log ~title "Looking for %a in the uid_to_loc table" + Logger.fmt (fun fmt -> Shape.Uid.print fmt uid); + let tbl = Ast_iterators.build_uid_to_locs_tbl ~local_defs () in + match Shape.Uid.Tbl.find_opt tbl uid with + | Some { Location.loc; _ } -> `Some (uid, loc) + | None -> log ~title "Uid not found in the local table."; `None + end else begin + log ~title "Loading the cmt file for unit %S" comp_unit; + match load_cmt ~config comp_unit with + | Ok (_pos_fname, cmt) -> + log ~title "Shapes successfully loaded, looking for %a" + Logger.fmt (fun fmt -> Shape.Uid.print fmt uid); + begin match Shape.Uid.Tbl.find_opt cmt.cmt_uid_to_decl uid with + | Some decl -> loc_of_decl ~uid decl + | None -> log ~title "Uid not found in the cmt's table."; `None + end + | _ -> log ~title "Failed to load the cmt file"; `None + end - let in_namespaces (nss : Namespace.inferred list) ident env = - let open Shape.Sig_component_kind in - try - List.iter nss ~f:(fun namespace -> - try - match namespace with - | `This_cstr ({ Types.cstr_tag = Cstr_extension _; _ } as cd) -> - log ~title:"lookup" - "got extension constructor"; - let path, loc = path_and_loc_of_cstr cd env in - (* TODO: Use [`Constr] here instead of [`Type] *) - raise (Found (path, Extension_constructor, cd.cstr_uid, loc)) - | `This_cstr cd -> - log ~title:"lookup" - "got constructor, fetching path and loc in type namespace"; - let path, loc = path_and_loc_of_cstr cd env in - (* TODO: Use [`Constr] here instead of [`Type] *) - raise (Found (path, Type, cd.cstr_uid,loc)) - | `Constr -> - log ~title:"lookup" "lookup in constructor namespace" ; - let cd = Env.find_constructor_by_name ident env in - let path, loc = path_and_loc_of_cstr cd env in - (* TODO: Use [`Constr] here instead of [`Type] *) - raise (Found (path, Type,cd.cstr_uid, loc)) - | `Mod -> - log ~title:"lookup" "lookup in module namespace" ; - let path, md = Env.find_module_by_name ident env in - raise (Found (path, Module, md.md_uid, md.Types.md_loc)) - | `Modtype -> - log ~title:"lookup" "lookup in module type namespace" ; - let path, mtd = Env.find_modtype_by_name ident env in - raise (Found (path, Module_type, mtd.mtd_uid, mtd.Types.mtd_loc)) - | `Type -> - log ~title:"lookup" "lookup in type namespace" ; - let path, typ_decl = Env.find_type_by_name ident env in - raise ( - Found (path, Type, typ_decl.type_uid, typ_decl.Types.type_loc) - ) - | `Vals -> - log ~title:"lookup" "lookup in value namespace" ; - let path, val_desc = Env.find_value_by_name ident env in - raise ( - Found (path, Value, val_desc.val_uid, val_desc.Types.val_loc) - ) - | `This_label lbl -> - log ~title:"lookup" - "got label, fetching path and loc in type namespace"; - let path, loc = path_and_loc_from_label lbl env in - (* TODO: Use [`Labels] here instead of [`Type] *) - raise (Found (path, Type, lbl.lbl_uid, loc)) - | `Labels -> - log ~title:"lookup" "lookup in label namespace" ; - let lbl = Env.find_label_by_name ident env in - let path, loc = path_and_loc_from_label lbl env in - (* TODO: Use [`Labels] here instead of [`Type] *) - raise (Found (path, Type, lbl.lbl_uid, loc)) - with Not_found -> () - ) ; - log ~title:"lookup" " ... not in the environment" ; - None - with Found ((path, namespace, decl_uid, _loc) as x) -> - log ~title:"env_lookup" "found: '%a' in namespace %s with uid %a" - Logger.fmt (fun fmt -> Path.print fmt path) - (Shape.Sig_component_kind.to_string namespace) - Logger.fmt (fun fmt -> Shape.Uid.print fmt decl_uid); - Some x -end +let find_loc_of_comp_unit ~config uid comp_unit = + let title = "find_loc_of_comp_unit" in + log ~title "Got the uid of a compilation unit: %s" comp_unit; + match load_cmt ~config comp_unit with + | Ok (pos_fname, _cmt) -> + let pos = Std.Lexing.make_pos ~pos_fname (1, 0) in + let loc = { Location.loc_start=pos; loc_end=pos; loc_ghost=true } in + `Some (uid, loc) + | _ -> log ~title "Failed to load the CU's cmt"; `None + +let find_definition_uid ~config ~env ~(decl : Env_lookup.item) path = + let namespace = decl.namespace in + let module Reduce = Shape_reduce.Make (struct + let fuel = 10 -let uid_from_longident ~config ~env nss ml_or_mli ident = + let read_unit_shape ~unit_name = + log ~title:"read_unit_shape" "inspecting %s" unit_name; + match + load_cmt ~config:({config with ml_or_mli = `ML}) + ~with_fallback:false unit_name + with + | Ok (filename, cmt_infos) -> + move_to filename cmt_infos; + log ~title:"read_unit_shape" "shapes loaded for %s" unit_name; + cmt_infos.cmt_impl_shape + | Error () -> + log ~title:"read_unit_shape" "failed to find %s" unit_name; + None + end) + in + let shape = Env.shape_of_path ~namespace env path in + log ~title:"shape_of_path" "initial: %a" + Logger.fmt (Fun.flip Shape.print shape); + let reduced = Reduce.reduce_for_uid env shape + in + log ~title:"shape_of_path" "reduced: %a" + Logger.fmt (fun fmt -> Shape_reduce.print_result fmt reduced); + reduced + +let rec uid_of_result ~traverse_aliases = function + | Shape_reduce.Resolved uid -> + Some uid, false + | Resolved_alias ((Item { comp_unit; _ } | Compilation_unit comp_unit), + ((Resolved_alias (Compilation_unit comp_unit', _) + | Resolved (Compilation_unit comp_unit') ) as rest)) + when let by = comp_unit ^ "__" in String.is_prefixed ~by comp_unit' -> + (* Always traverse dune-wrapper aliases *) + log ~title:"uid_of_result" + "Traversing wrapping alias: %s__ %s" comp_unit comp_unit'; + uid_of_result ~traverse_aliases rest + | Resolved_alias (_alias, rest) when traverse_aliases -> + uid_of_result ~traverse_aliases rest + | Resolved_alias (alias, _rest) -> + Some alias, false + | Unresolved { uid = Some uid; desc = Comp_unit _; approximated } -> + Some uid, approximated + | Approximated _ | Unresolved _ | Internal_error_missing_uid -> + None, true + +(** This is the main function here *) +let from_path ~config ~env ~local_defs ~decl path = + let title = "from_path" in + let unalias (decl : Env_lookup.item) = + if not config.traverse_aliases then decl.uid else + let namespace = decl.namespace in + let uid = scrape_alias ~fallback_uid:decl.uid ~env ~namespace path in + if uid <> decl.uid then + log ~title:"uid_of_path" "Unaliased declaration uid: %a -> %a" + Logger.fmt (Fun.flip Shape.Uid.print decl.uid) + Logger.fmt (Fun.flip Shape.Uid.print uid); + uid + in + (* Step 1: Path => Uid *) + let decl : Env_lookup.item = { decl with uid = (unalias decl) } in + let uid, approximated = match config.ml_or_mli with + | `MLI -> decl.uid, false + | `ML -> + let traverse_aliases = config.traverse_aliases in + let result = find_definition_uid ~config ~env ~decl path in + match uid_of_result ~traverse_aliases result with + | Some uid, approx -> uid, approx + | None, _approx -> + log ~title "No definition uid, falling back to the declaration uid: %a" + Logger.fmt (Fun.flip Shape.Uid.print decl.uid); + decl.uid, true + in + (* Step 2: Uid => Location *) + let loc = match uid with + | Predef s -> `Builtin (uid, s) + | Internal -> `Builtin (uid, "") + | Item {comp_unit; _} -> find_loc_of_uid ~config ~local_defs uid comp_unit + | Compilation_unit comp_unit -> find_loc_of_comp_unit ~config uid comp_unit + in + let loc = match loc with + | `None -> + log ~title "Falling back to the declaration's location: %a" + Logger.fmt (Fun.flip Location.print_loc decl.loc); + `Some (decl.uid, decl.loc) + | other -> other + in + (* Step 3: Location => Source *) + match loc with + | `None -> assert false + | `Builtin _ as err -> err + | `Some (uid, loc) -> + match find_source ~config:config.mconfig loc (Path.name path) with + | `Found (file, location) -> + log ~title:"find_source" "Found file: %s (%a)" file + Logger.fmt (Fun.flip Location.print_loc location); + `Found { + uid; + decl_uid = decl.uid; + file; location; approximated } + | `File_not_found _ as otherwise -> otherwise + +let from_longident ~config ~env ~local_defs nss ident = let str_ident = try String.concat ~sep:"." (Longident.flatten ident) with _-> "Not a flat longident" in - match Env_lookup.in_namespaces nss ident env with + match Env_lookup.by_longident nss ident env with | None -> `Not_in_env str_ident - | Some (path, namespace, decl_uid, loc) -> - if Utils.is_builtin_path path then - `Builtin - else - let uid = uid_of_path ~config ~env ~ml_or_mli ~decl_uid path namespace in - `Uid (uid, loc, path) + | Some (path, decl) -> from_path ~config ~env ~local_defs ~decl path -let from_longident ~config ~env nss ml_or_mli ident = - match uid_from_longident ~config ~env nss ml_or_mli ident with - | `Uid (uid, loc, path) -> from_uid ~config ~ml_or_mli uid loc path - | (`Builtin | `Not_in_env _) as v -> v - -let from_path ~config ~env ~namespace ml_or_mli path = +let from_path ~config ~env ~local_defs ~namespace path = File_switching.reset (); - if Utils.is_builtin_path path then - `Builtin - else - match Env_lookup.loc path namespace env with - | None -> `Not_in_env (Path.name path) - | Some (loc, uid, namespace) -> - match locate ~config ~env ~ml_or_mli uid loc path namespace with - | `Not_found _ - | `File_not_found _ as err -> err - | `Found (uid, loc) -> - match find_source ~config loc (Path.name path) with - | `Found (file, loc) -> `Found (uid, file, loc) - | `File_not_found _ as otherwise -> otherwise + match Env_lookup.by_path path namespace env with + | None -> `Not_in_env (Path.name path) + | Some decl -> from_path ~config ~env ~local_defs ~decl path let infer_namespace ?namespaces ~pos lid browse is_label = match namespaces with | Some nss -> if not is_label - then `Ok (nss :> Namespace.inferred list) + then `Ok (nss :> Env_lookup.Namespace.inferred list) else if List.mem `Labels ~set:nss then ( log ~title:"from_string" "restricting namespaces to labels"; `Ok [ `Labels ] @@ -787,13 +678,13 @@ let infer_namespace ?namespaces ~pos lid browse is_label = | Some ctxt, false -> log ~title:"from_string" "inferred context: %s" (Context.to_string ctxt); - `Ok (Namespace.from_context ctxt) + `Ok (Env_lookup.Namespace.from_context ctxt) | _, true -> log ~title:"from_string" "dropping inferred context, it is not precise enough"; `Ok [ `Labels ] -let from_string ~config ~env ~local_defs ~pos ?namespaces switch path = +let from_string ~config ~env ~local_defs ~pos ?namespaces path = File_switching.reset (); let browse = Mbrowse.of_typedtree local_defs in let lid = Type_utils.parse_longident path in @@ -804,14 +695,8 @@ let from_string ~config ~env ~local_defs ~pos ?namespaces switch path = | `Ok nss -> log ~title:"from_string" "looking for the source of '%s' (prioritizing %s files)" - path (match switch with `ML -> ".ml" | `MLI -> ".mli"); - match from_longident ~config ~env nss switch ident with - | `File_not_found _ | `Not_found _ | `Not_in_env _ as err -> err - | `Builtin -> `Builtin path - | `Found (uid, loc) -> - match find_source ~config loc path with - | `Found (file, loc) -> `Found (uid, file, loc) - | `File_not_found _ as otherwise -> otherwise + path (match config.ml_or_mli with `ML -> ".ml" | `MLI -> ".mli"); + from_longident ~config ~env ~local_defs nss ident in Option.value_map ~f:from_lid ~default:(`Not_found (path, None)) lid @@ -864,8 +749,8 @@ let find_doc_attributes_in_typedtree ~config ~comp_unit uid = let rec aux pat = let open Typedtree in match pat.pat_desc with - | Tpat_var (id, _) -> f id - | Tpat_alias (pat, _, _) + | Tpat_var (id, _, _) -> f id + | Tpat_alias (pat, _, _, _) | Tpat_variant (_, Some pat, _) | Tpat_lazy pat | Tpat_or (pat, _, _) -> @@ -890,7 +775,7 @@ let find_doc_attributes_in_typedtree ~config ~comp_unit uid = in let typedtree = log ~title:"doc_from_uid" "Loading the cmt for unit %S" comp_unit; - match load_cmt ~config comp_unit `MLI with + match load_cmt ~config:({config with ml_or_mli = `MLI}) comp_unit with | Ok (_, cmt_infos) -> log ~title:"doc_from_uid" "Cmt loaded, itering on the typedtree"; begin match cmt_infos.cmt_annots with @@ -932,8 +817,8 @@ let find_doc_attributes_in_typedtree ~config ~comp_unit uid = let doc_from_uid ~config ~loc uid = begin match uid with - | Some (Shape.Uid.Item { comp_unit; _ } as uid) - | Some (Shape.Uid.Compilation_unit comp_unit as uid) + | Shape.Uid.Item { comp_unit; _ } + | Shape.Uid.Compilation_unit comp_unit when Env.get_unit_name () <> comp_unit -> log ~title:"get_doc" "the doc (%a) you're looking for is in another compilation unit (%s)" @@ -989,38 +874,35 @@ let doc_from_comment_list ~local_defs ~buffer_comments loc = | None, _ -> `No_documentation | Some doc, _ -> `Found doc -let get_doc ~config ~env ~local_defs ~comments ~pos = +let get_doc ~config:mconfig ~env ~local_defs ~comments ~pos = File_switching.reset (); fun path -> let_ref last_location Location.none @@ fun () -> + let config = { mconfig; ml_or_mli = `MLI; traverse_aliases = true; } in let doc_from_uid_result = match path with | `Completion_entry (namespace, path, _loc) -> log ~title:"get_doc" "completion: looking for the doc of '%a'" Logger.fmt (fun fmt -> Path.print fmt path) ; - let from_path = from_path ~config ~env ~namespace `MLI path in + + let from_path = + from_path ~config ~env ~local_defs ~namespace path + in begin match from_path with - | `Found (uid, _, pos) -> - let loc : Location.t = - { loc_start = pos; loc_end = pos; loc_ghost = true } - in + | `Found { uid; location = loc; _ } -> doc_from_uid ~config ~loc uid - | (`Builtin |`Not_in_env _|`File_not_found _|`Not_found _) + | (`Builtin _ |`Not_in_env _|`File_not_found _|`Not_found _) as otherwise -> otherwise end | `User_input path -> log ~title:"get_doc" "looking for the doc of '%s'" path; - begin match from_string ~config ~env ~local_defs ~pos `MLI path with - | `Found (uid, _, pos) -> - let loc : Location.t = - { loc_start = pos; loc_end = pos; loc_ghost = true } - in + begin match from_string ~config ~env ~local_defs ~pos path with + | `Found { uid; location = loc; _ } -> doc_from_uid ~config ~loc uid | `At_origin -> `Found_loc { Location.loc_start = pos; loc_end = pos; loc_ghost = true } | `Missing_labels_namespace -> `No_documentation - | `Builtin _ -> `Builtin - | (`Not_in_env _ | `Not_found _ |`File_not_found _ ) + | (`Builtin _ | `Not_in_env _ | `Not_found _ |`File_not_found _ ) as otherwise -> otherwise end in @@ -1028,7 +910,7 @@ let get_doc ~config ~env ~local_defs ~comments ~pos = | `Found_doc doc -> `Found doc | `Found_loc loc -> doc_from_comment_list ~local_defs ~buffer_comments:comments loc - | `Builtin -> + | `Builtin _ -> begin match path with | `User_input path -> `Builtin path | `Completion_entry (_, path, _) -> `Builtin (Path.name path) diff --git a/src/analysis/locate.mli b/src/analysis/locate.mli index 581d75c294..0d201bcd8b 100644 --- a/src/analysis/locate.mli +++ b/src/analysis/locate.mli @@ -28,33 +28,54 @@ val log : 'a Logger.printf -module Namespace : sig - type t = [ `Type | `Mod | `Modtype | `Vals | `Constr | `Labels ] -end +type config = { + mconfig: Mconfig.t; + ml_or_mli: [ `ML | `MLI ]; + traverse_aliases: bool; +} + +type result = { + uid: Shape.Uid.t; + decl_uid: Shape.Uid.t; + file: string; + location: Location.t; + approximated: bool; +} + +val uid_of_result + : traverse_aliases:bool + -> Shape_reduce.result + -> Shape.Uid.t option * bool + +val find_source + : config: Mconfig.t + -> Warnings.loc + -> string + -> [> `File_not_found of string + | `Found of string * Location.t ] val from_path - : config:Mconfig.t + : config:config -> env:Env.t - -> namespace:Namespaced_path.Namespace.t - -> [ `ML | `MLI ] + -> local_defs:Mtyper.typedtree + -> namespace:Env_lookup.Namespace.t -> Path.t -> [> `File_not_found of string - | `Found of Shape.Uid.t option * string option * Lexing.position - | `Builtin + | `Found of result + | `Builtin of Shape.Uid.t * string | `Not_in_env of string | `Not_found of string * string option ] val from_string - : config:Mconfig.t + : config:config -> env:Env.t -> local_defs:Mtyper.typedtree -> pos:Lexing.position - -> ?namespaces:Namespace.t list - -> [ `ML | `MLI ] + -> ?namespaces:Env_lookup.Namespace.inferred_basic list -> string -> [> `File_not_found of string - | `Found of Shape.Uid.t option * string option * Lexing.position - | `Builtin of string + | `Found of result + | `Builtin of Shape.Uid.t * string | `Missing_labels_namespace | `Not_found of string * string option | `Not_in_env of string @@ -67,8 +88,7 @@ val get_doc -> comments:(string * Location.t) list -> pos:Lexing.position -> [ `User_input of string - | `Completion_entry of - Namespaced_path.Namespace.t * Path.t * Location.t ] + | `Completion_entry of Env_lookup.Namespace.t * Path.t * Location.t ] -> [> `File_not_found of string | `Found of string | `Builtin of string diff --git a/src/analysis/misc_utils.ml b/src/analysis/misc_utils.ml index 5312a2b16d..12ce609f68 100644 --- a/src/analysis/misc_utils.ml +++ b/src/analysis/misc_utils.ml @@ -58,13 +58,48 @@ let parenthesize_name name = "(" ^ name ^ ")" ) +let parse_identifier (config, source) pos = + let path = Mreader.reconstruct_identifier config source pos in + let path = Mreader_lexer.identifier_suffix path in + Logger.log + ~section:Type_enclosing.log_section + ~title:"reconstruct-identifier" + "paths: [%s]" + (String.concat ~sep:";" (List.map path + ~f:(fun l -> l.Location.txt))); + path + module Compat = struct open Typedtree let pat_var_id_and_loc = function - | { pat_desc = Tpat_var (id, loc); _ } -> Some (id, loc) + | { pat_desc = Tpat_var (id, loc, _); _ } -> Some (id, loc) | _ -> None let pat_alias_pat_id_and_loc = function - | { pat_desc = Tpat_alias (pat, id, loc); _ } -> Some (pat, id, loc) + | { pat_desc = Tpat_alias (pat, id, loc, _); _ } -> Some (pat, id, loc) | _ -> None end + +let loc_of_decl ~uid = + let of_option name = + match name.Location.txt with + | Some txt -> Some { name with txt } + | None -> None + in + let of_value_binding vb = + let bound_idents = Typedtree.let_bound_idents_full [vb] in + ListLabels.find_map ~f:(fun (_, loc, _, uid') -> if uid = uid' then Some loc else None) bound_idents + in + function + | Typedtree.Value vd -> Some vd.val_name + | Value_binding vb -> of_value_binding vb + | Type td -> Some td.typ_name + | Constructor cd -> Some cd.cd_name + | Extension_constructor ec -> Some ec.ext_name + | Label ld -> Some ld.ld_name + | Module md -> of_option md.md_name + | Module_binding mb -> of_option mb.mb_name + | Module_type mtd -> Some mtd.mtd_name + | Module_substitution msd -> Some msd.ms_name + | Class cd -> Some cd.ci_id_name + | Class_type ctd -> Some ctd.ci_id_name diff --git a/src/analysis/misc_utils.mli b/src/analysis/misc_utils.mli index 27385cb806..9962d80db2 100644 --- a/src/analysis/misc_utils.mli +++ b/src/analysis/misc_utils.mli @@ -1,3 +1,5 @@ +open Misc + module Path : sig (** [to_shortest_lid ~env ~env_check path] will make a [Longident.t] from the provided [Path.t] and attempt to use the shortest prefix possible given the @@ -23,6 +25,11 @@ end (* Add parenthesis to qualified operators *) val parenthesize_name : string -> string +(** [parse_identifier] attempts to re-parse a longident so that we get + the location of each of its components. *) +val parse_identifier : + (Mconfig.t * Msource.t) -> Lexing.position -> modname Location.loc list + module Compat : sig val pat_var_id_and_loc : Typedtree.pattern -> (Ident.t * string Location.loc) option @@ -31,3 +38,9 @@ module Compat : sig : Typedtree.pattern -> (Typedtree.pattern * Ident.t * string Location.loc) option end + +(** Extracts the location of a [uid] from a [Typedtree.item_declaration] *) +val loc_of_decl : + uid:Shape.Uid.t -> + Typedtree.item_declaration -> + string Location.loc option diff --git a/src/analysis/namespaced_path.ml b/src/analysis/namespaced_path.ml deleted file mode 100644 index 2ade36f4c7..0000000000 --- a/src/analysis/namespaced_path.ml +++ /dev/null @@ -1,133 +0,0 @@ -open Std - -module Namespace = struct - type t = [ - | `Vals - | `Type - | `Constr - | `Mod - | `Modtype - | `Functor - | `Labels - | `Unknown - | `Apply - ] - - let to_tag_string = function - | `Mod -> "" - | `Functor -> "[functor]" - | `Labels -> "[label]" - | `Constr -> "[cstr]" - | `Type -> "[type]" - | `Vals -> "[val]" - | `Modtype -> "[Mty]" - | `Unknown -> "[?]" - | `Apply -> "[functor application]" - - let to_string = function - | `Mod -> "(module) " - | `Functor -> "(functor)" - | `Labels -> "(label) " - | `Constr -> "(constructor) " - | `Type -> "(type) " - | `Vals -> "(value) " - | `Modtype -> "(module type) " - | `Unknown -> "(unknown)" - | `Apply -> "(functor application)" -end - -module Id = struct - type t = - | Id of Ident.t - | String of string - - let name = function - | Id id -> Ident.name id - | String s -> s - - let unique_name = function - | Id id -> Ident.unique_toplevel_name id - | String s -> s - - let equal mi1 mi2 = - match mi1, mi2 with - | Id i1, Id i2 -> Ident.equal i1 i2 - | Id i, String s - | String s, Id i -> (Ident.name i) = s - | String s1, String s2 -> s1 = s2 -end - -type t = elt list -and elt = - | Ident of Id.t * Namespace.t - | Applied_to of t - -let rec to_string ~name = function - | [] - | Applied_to _ :: _ -> invalid_arg "Namespaced_path.to_string" - | Ident (id, ns) :: rest -> - List.fold_left rest ~init:(name id ^ Namespace.to_tag_string ns) ~f:( - fun acc elt -> - match elt with - | Ident (id, ns) -> - Printf.sprintf "%s.%s%s" acc (name id) (Namespace.to_tag_string ns) - | Applied_to arg -> - Printf.sprintf "%s(%s)" acc (to_string ~name arg) - ) - -let to_unique_string l = to_string ~name:Id.unique_name l -let to_string l = to_string ~name:Id.name l - -let of_path ~namespace p = - let rec aux namespace acc p = - let open Path in - match p with - | Pident id -> Ident (Id.Id id, namespace) :: acc - | Pdot (p, s) -> aux `Mod (Ident (Id.String s, namespace) :: acc) p - | Papply (p1, p2) -> - let acc = - Applied_to (aux `Mod [] p2) :: acc - in - aux `Mod acc p1 - in - aux namespace [] p - -let head_exn = function - | [] -> invalid_arg "head" - | x :: _ -> x - -let head x = - try Some (head_exn x) - with Invalid_argument _ -> None - -let peal_head_exn = function - | [] -> invalid_arg "peal_head_exn" - | _head :: rest -> rest - -let peal_head p = - try Some (peal_head_exn p) - with Invalid_argument _ -> None - -let rec equal p1 p2 = List.equal ~eq:equal_elt p1 p2 -and equal_elt elt1 elt2 = - match elt1, elt2 with - | Ident (i1, ns1), Ident (i2, ns2) -> Id.equal i1 i2 && ns1 = ns2 - | Applied_to p1, Applied_to p2 -> equal p1 p2 - | _, _ -> false - -let rewrite_head ~new_prefix p = new_prefix @ p - -let strip_stamps = - List.map ~f:(function - | Ident (Id i, ns) -> Ident (String (Ident.name i), ns) - | elt -> elt - ) - -let empty = [] - -let rec subst_prefix ~old_prefix ~new_prefix p = - match old_prefix, p with - | [], _ -> Some (new_prefix @ p) - | op1 :: ops, elt1 :: p when equal_elt op1 elt1 -> - subst_prefix ~old_prefix:ops ~new_prefix p - | _ -> None diff --git a/src/analysis/namespaced_path.mli b/src/analysis/namespaced_path.mli deleted file mode 100644 index 4e4a75cec2..0000000000 --- a/src/analysis/namespaced_path.mli +++ /dev/null @@ -1,49 +0,0 @@ -module Namespace : sig - type t = [ - | `Vals - | `Type - | `Constr - | `Mod - | `Modtype - | `Functor - | `Labels - | `Unknown - | `Apply - ] - - val to_string : t -> string -end - -module Id : sig - type t = private - | Id of Ident.t - | String of string - - val name : t -> string -end - -type t (* = private elt list *) -and elt = private - | Ident of Id.t * Namespace.t - | Applied_to of t - -val to_string : t -> string -val to_unique_string : t -> string - -val head : t -> elt option -val head_exn : t -> elt - -val peal_head : t -> t option -val peal_head_exn : t -> t - -val equal : t -> t -> bool - -val rewrite_head : new_prefix:t -> t -> t - -val strip_stamps : t -> t - -val of_path : namespace:Namespace.t -> Path.t -> t - -val empty : t - -val subst_prefix : old_prefix:t -> new_prefix:t -> t -> t option diff --git a/src/analysis/occurrences.ml b/src/analysis/occurrences.ml new file mode 100644 index 0000000000..a1236a483b --- /dev/null +++ b/src/analysis/occurrences.ml @@ -0,0 +1,255 @@ +open Std +module LidSet = Index_format.LidSet + +let {Logger. log} = Logger.for_section "occurrences" + +let set_fname ~file (loc : Location.t) = + let pos_fname = file in + { loc with + loc_start = { loc.loc_start with pos_fname }; + loc_end = { loc.loc_end with pos_fname }} + +let decl_of_path_or_lid env namespace path lid = + match (namespace : Shape.Sig_component_kind.t) with + | Constructor -> + begin match Env.find_constructor_by_name lid env with + | exception Not_found -> None + | {cstr_uid; cstr_loc; _ } -> + Some { Env_lookup.uid = cstr_uid; loc = cstr_loc; namespace } + end + | Label -> + begin match Env.find_label_by_name lid env with + | exception Not_found -> None + | {lbl_uid; lbl_loc; _ } -> + Some { Env_lookup.uid = lbl_uid; loc = lbl_loc; namespace } + end + | _ -> Env_lookup.by_path path namespace env + +let index_buffer_ ~config ~source ~current_buffer_path ~local_defs () = + let {Logger. log} = Logger.for_section "index" in + let defs = Hashtbl.create 64 in + let module Shape_reduce = + Shape_reduce.Make (struct + let fuel = 10 + + let read_unit_shape ~unit_name = + log ~title:"read_unit_shape" "inspecting %s" unit_name; + let cmt = Format.sprintf "%s.cmt" unit_name in + match Cmt_cache.read (Load_path.find_normalized cmt) with + | { cmt_infos = { cmt_impl_shape; _ }; _ } -> + log ~title:"read_unit_shape" "shapes loaded for %s" unit_name; + cmt_impl_shape + | exception _ -> + log ~title:"read_unit_shape" "failed to find %s" unit_name; + None + end) + in + let f ~namespace env path (lid : Longident.t Location.loc) = + log ~title:"index_buffer" "Path: %a" Logger.fmt (Fun.flip Path.print path); + let not_ghost { Location.loc = { loc_ghost; _ }; _ } = not loc_ghost in + let lid = { lid with loc = set_fname ~file:current_buffer_path lid.loc } in + let index_decl () = + begin match decl_of_path_or_lid env namespace path lid.txt with + | exception _ | None -> log ~title:"index_buffer" "Declaration not found" + | Some decl -> + log ~title:"index_buffer" "Found declaration: %a" + Logger.fmt (Fun.flip Location.print_loc decl.loc); + Index_format.(add defs decl.uid (LidSet.singleton lid)) + end + in + if not_ghost lid then + match Env.shape_of_path ~namespace env path with + | exception Not_found -> () + | path_shape -> + log ~title:"index_buffer" "Shape of path: %a" + Logger.fmt (Fun.flip Shape.print path_shape); + let result = Shape_reduce.reduce_for_uid env path_shape in + begin match Locate.uid_of_result ~traverse_aliases:false result with + | Some uid, false -> + log ~title:"index_buffer" "Found %a (%a) wiht uid %a" + Logger.fmt (Fun.flip Pprintast.longident lid.txt) + Logger.fmt (Fun.flip Location.print_loc lid.loc) + Logger.fmt (Fun.flip Shape.Uid.print uid); + Index_format.(add defs uid (LidSet.singleton lid)) + | Some uid, true -> + log ~title:"index_buffer" "Shape is approximative, found uid: %a" + Logger.fmt (Fun.flip Shape.Uid.print uid); + index_decl () + | None, _ -> + log ~title:"index_buffer" "Reduction failed: missing uid"; + index_decl () + end + in + let f ~namespace env path (lid : Longident.t Location.loc) = + (* The compiler lacks sufficient location information to precisely hihglight + modules in paths. This function hacks around that issue when looking for + occurrences in the current buffer only. *) + (* We rely on a custom re-parsing of the longidents that provide us with + location information and match these with the real path and longident. *) + let rec iter_on_path ~namespace (path : Path.t) lid reparsed = + log ~title:"iter_on_path" "Path %a, lid: %a" + Logger.fmt (Fun.flip Path.print path) + Logger.fmt (Fun.flip Pprintast.longident lid.Location.txt); + match path, lid.txt, reparsed with + | Pdot (path', n), (Ldot (_, s) | Lident s), _ + when n <> s && String.lowercase_ascii n = n -> + iter_on_path ~namespace path' lid reparsed + | (Pdot _ | Pident _), Lident s, [{ Location.txt = name; loc}] + when name = s -> + log ~title:"iter_on_path" "Last %a, lid: %a" + Logger.fmt (Fun.flip Path.print path) + Logger.fmt (Fun.flip Pprintast.longident lid.Location.txt); + f ~namespace env path { lid with loc = loc } + | Pdot (path', _), Ldot (lid', s), { txt = name; loc} :: tl when name = s -> + let () = f ~namespace env path { lid with loc = loc } in + iter_on_path ~namespace:Module path' { lid with txt = lid' } tl + | Papply _, _, _ -> f ~namespace env path lid + | _, _, _ -> f ~namespace env path lid + in + let reparsed_lid = + Misc_utils.parse_identifier (config, source) lid.loc.loc_end + |> List.rev + in + iter_on_path ~namespace path lid reparsed_lid + in + Ast_iterators.iter_on_usages ~f local_defs; + defs + +let index_buffer = + (* Right now, we only cache the last used index. We could do better by caching + the index for every known buffer. *) + let cache = ref None in + fun ~config ~source ~current_buffer_path ~stamp ~local_defs () -> + let {Logger. log} = Logger.for_section "index" in + match !cache with + | Some (path, stamp', value) when + String.equal path current_buffer_path + && Int.equal stamp' stamp -> + log ~title:"index_cache" "Reusing cached value for path %s and stamp %i." + path stamp'; + value + | _ -> + log ~title:"index_cache" "No valid cache found, reindexing."; + let result = + index_buffer_ ~config ~source ~current_buffer_path ~local_defs () + in + cache := Some (current_buffer_path, stamp, result); + result + +(* A longident can have the form: A.B.x Right now we are only interested in + values, but we will eventually want to index all occurrences of modules in + such longidents. However there is an issue with that: we only have the + location of the complete longident which might span multiple lines. This is + enough to get the last component since it will always be on the last line, + but will prevent us to find the location of previous components. + + However, we can safely deduce the location of the last part of the lid only + when the ident does not require parenthesis. In that case the loc sie differs + from the name size in a way that depends on the concrete syntax which is + lost. *) +let last_loc (loc : Location.t) lid = + match lid with + | Longident.Lident _ -> loc + | _ -> + let last_segment = Longident.last lid in + let needs_parens = Pprintast.needs_parens last_segment in + if not needs_parens then + let last_size = last_segment |> String.length in + { loc with + loc_start = { loc.loc_end with + pos_cnum = loc.loc_end.pos_cnum - last_size; + } + } + else + loc + +let uid_and_loc_of_node env node = + let open Browse_raw in + log ~title:"occurrences" "Looking for uid of node %s" + @@ string_of_node node; + match node with + | Module_binding_name { mb_id = Some ident; mb_name; _ } -> + let md = Env.find_module (Pident ident) env in + Some (md.md_uid, mb_name.loc) + | Pattern { pat_desc = + Tpat_var (_, name, uid) | Tpat_alias (_, _, name, uid); _ } -> + Some (uid, name.loc) + | Type_declaration { typ_type; typ_name; _ } -> + Some (typ_type.type_uid, typ_name.loc) + | Label_declaration { ld_uid; ld_loc ; _ } -> + Some (ld_uid, ld_loc) + | Constructor_declaration { cd_uid; cd_loc ; _ } -> + Some (cd_uid, cd_loc) + | Value_description { val_val; val_name; _ } -> + Some (val_val.val_uid, val_name.loc) + | _ -> None + +let comp_unit_of_uid = function + | Shape.Uid.Compilation_unit comp_unit + | Item { comp_unit; _ } -> Some comp_unit + | Internal | Predef _ -> None + +let locs_of ~config ~source ~env ~typer_result ~pos path = + log ~title:"occurrences" "Looking for occurences of %s (pos: %s)" + path + (Lexing.print_position () pos); + let local_defs = Mtyper.get_typedtree typer_result in + let locate_result = + Locate.from_string + ~config:{ mconfig = config; traverse_aliases=false; ml_or_mli = `ML} + ~env ~local_defs ~pos path + in + let def = + match locate_result with + | `At_origin -> + log ~title:"locs_of" "Cursor is on definition / declaration"; + (* We are on a definition / declaration so we look for the node's uid *) + let browse = Mbrowse.of_typedtree local_defs in + let env, node = Mbrowse.leaf_node (Mbrowse.enclosing pos [browse]) in + uid_and_loc_of_node env node + | `Found { uid; location; approximated = false; _ } -> + log ~title:"locs_of" "Found definition uid using locate: %a " + Logger.fmt (fun fmt -> Shape.Uid.print fmt uid); + Some (uid, location) + | `Found { decl_uid; location; approximated = true; _ } -> + log ~title:"locs_of" "Approx: %a " + Logger.fmt (fun fmt -> Shape.Uid.print fmt decl_uid); + Some (decl_uid, location) + | `Builtin (uid, s) -> + log ~title:"locs_of" "Locate found a builtin: %s" s; + Some (uid, Location.none) + | _ -> + log ~title:"locs_of" "Locate failed to find a definition."; + None + in + let current_buffer_path = + Filename.concat config.query.directory config.query.filename + in + match def with + | Some (def_uid, def_loc) -> + log ~title:"locs_of" "Definition has uid %a (%a)" + Logger.fmt (fun fmt -> Shape.Uid.print fmt def_uid) + Logger.fmt (fun fmt -> Location.print_loc fmt def_loc); + log ~title:"locs_of" "Indexing current buffer"; + let buffer_index = + let stamp = Mtyper.get_stamp typer_result in + index_buffer ~config ~source ~current_buffer_path ~stamp ~local_defs () + in + let buffer_locs = Hashtbl.find_opt buffer_index def_uid in + let locs = Option.value ~default:LidSet.empty buffer_locs in + let locs = + log ~title:"occurrences" "Found %i locs" (LidSet.cardinal locs); + LidSet.elements locs + |> List.map ~f:(fun {Location.txt; loc} -> + log ~title:"occurrences" "Found occ: %s %a" + (Longident.head txt) Logger.fmt (Fun.flip Location.print_loc loc); + last_loc loc txt) + in + let def_uid_is_in_current_unit = + let uid_comp_unit = comp_unit_of_uid def_uid in + Option.value_map ~default:false uid_comp_unit + ~f:(String.equal @@ Env.get_unit_name ()) + in + if not def_uid_is_in_current_unit then Ok locs + else Ok (set_fname ~file:current_buffer_path def_loc :: locs) + | None -> Error "Could not find the uid of the definition." diff --git a/src/analysis/occurrences.mli b/src/analysis/occurrences.mli new file mode 100644 index 0000000000..871341430c --- /dev/null +++ b/src/analysis/occurrences.mli @@ -0,0 +1,8 @@ +val locs_of + : config:Mconfig.t + -> source:Msource.t + -> env:Env.t + -> typer_result:Mtyper.result + -> pos:Lexing.position + -> string + -> (Warnings.loc list, string) result diff --git a/src/analysis/outline.ml b/src/analysis/outline.ml index ed179236ca..54a64a0e71 100644 --- a/src/analysis/outline.ml +++ b/src/analysis/outline.ml @@ -36,7 +36,7 @@ open Browse_raw open Browse_tree let id_of_patt = function - | { pat_desc = Tpat_var (id, _) ; _ } -> Some id + | { pat_desc = Tpat_var (id, _, _) ; _ } -> Some id | _ -> None let mk ?(children=[]) ~location ~deprecated outline_kind outline_type id = diff --git a/src/analysis/polarity_search.ml b/src/analysis/polarity_search.ml index ee224c12d1..43ff256cc8 100644 --- a/src/analysis/polarity_search.ml +++ b/src/analysis/polarity_search.ml @@ -24,7 +24,9 @@ let rec normalize_path env path = | decl -> match decl.Types.type_manifest with | Some body when decl.Types.type_private = Asttypes.Public - || decl.Types.type_kind <> Types.Type_abstract -> + || (match decl.Types.type_kind with + | Types.Type_abstract _ -> false + | _ -> true) -> begin match Types.get_desc body with | Types.Tconstr (path, _, _) -> normalize_path env path | _ -> path diff --git a/src/analysis/ptyp_of_type.ml b/src/analysis/ptyp_of_type.ml index 3f76d4c704..8c71b56405 100644 --- a/src/analysis/ptyp_of_type.ml +++ b/src/analysis/ptyp_of_type.ml @@ -152,7 +152,7 @@ and type_declaration id { = let params = List.map2 type_params type_variance ~f:(fun type_ variance -> let core_type = core_type type_ in - let pos, neg, _inv, inj = Types.Variance.get_lower variance in + let pos, neg, inj = Types.Variance.get_lower variance in let v = if pos then Asttypes.Covariant else (if neg then Contravariant else NoVariance) @@ -161,7 +161,7 @@ and type_declaration id { core_type, (v, i)) in let kind = match type_kind with - | Type_abstract -> Parsetree.Ptype_abstract + | Type_abstract _ -> Parsetree.Ptype_abstract | Type_open -> Ptype_open | Type_variant (constrs, _) -> Ptype_variant (List.map ~f:constructor_declaration constrs) @@ -228,9 +228,9 @@ and group_items (items : Types.signature_item list) = | Sig_type (id, type_decl, Trec_not, _) :: rest -> let type_, rest = read_type [type_declaration id type_decl] rest in group (Type (Asttypes.Nonrecursive, type_) :: acc) rest - | Sig_class _ as item :: _ :: _ :: _ :: rest -> + | Sig_class _ as item :: _ :: _ :: rest -> group (Item item :: acc) rest - | Sig_class_type _ as item :: _ :: _ :: rest -> + | Sig_class_type _ as item :: _ :: rest -> group (Item item :: acc) rest | item :: rest -> group (Item item :: acc) rest | [] -> List.rev acc diff --git a/src/analysis/syntax_doc.ml b/src/analysis/syntax_doc.ml index 49335d12cd..9b1299973a 100644 --- a/src/analysis/syntax_doc.ml +++ b/src/analysis/syntax_doc.ml @@ -190,13 +190,12 @@ let get_syntax_doc cursor_loc node : syntax_info = } | (_, Expression _) :: (_, Expression _) - :: (_, Case _) :: (_, Expression _) :: ( _, Value_binding { vb_expr = - { exp_extra = [ (Texp_newtype' (_, loc), _, _) ]; exp_loc; _ }; + { exp_extra = [ (Texp_newtype' (_, loc, _), _, _) ]; exp_loc; _ }; _; } ) :: _ -> ( diff --git a/src/analysis/tail_analysis.ml b/src/analysis/tail_analysis.ml index 3e75a758d7..d05e2ac37e 100644 --- a/src/analysis/tail_analysis.ml +++ b/src/analysis/tail_analysis.ml @@ -74,7 +74,9 @@ let tail_positions = function (* If the expression is a function, return all of its entry-points (which are in tail-positions). Returns an empty list otherwise *) let expr_entry_points = function - | Texp_function {cases; _} -> List.map cases ~f:(fun c -> Case c) + (* FIXME This was broken with the upgrade to 5.2 + It seems like that feature was already broket before that upgrade. *) + (* | Texp_function (cases, _) -> List.map cases ~f:(fun c -> Case c) *) | _ -> [] let entry_points = function diff --git a/src/analysis/type_utils.ml b/src/analysis/type_utils.ml index 8ad734bd83..a2c87b7ed1 100644 --- a/src/analysis/type_utils.ml +++ b/src/analysis/type_utils.ml @@ -31,7 +31,7 @@ open Std module Verbosity = Mconfig.Verbosity let protect expr = - Pprintast.protect_ident (Format.str_formatter) expr; + Pprintast.ident_of_name (Format.str_formatter) expr; Format.flush_str_formatter () let parse_expr ?(keywords=Lexer_raw.keywords []) expr = @@ -216,7 +216,7 @@ let print_type_with_decl ~verbosity env ppf typ = in let is_abstract = match decl.Types.type_kind with - | Types.Type_abstract -> true + | Types.Type_abstract _ -> true | _ -> false in (* Print expression only if it is parameterized or abstract *) @@ -234,8 +234,9 @@ let print_type_with_decl ~verbosity env ppf typ = end; let ident = match path with | Path.Papply _ -> assert false - | Path.Pdot _ -> Ident.create_persistent (Path.last path) | Path.Pident ident -> ident + | Path.Pdot _ | Path.Pextra_ty _ -> + Ident.create_persistent (Path.last path) in Printtyp.type_declaration env ident ppf decl end diff --git a/src/config/gen_config.ml b/src/config/gen_config.ml index 9919271aa3..99fa4ceeef 100644 --- a/src/config/gen_config.ml +++ b/src/config/gen_config.ml @@ -17,5 +17,5 @@ let ocamlversion : | `OCaml_4_03_0 | `OCaml_4_04_0 | `OCaml_4_05_0 | `OCaml_4_06_0 | `OCaml_4_07_0 | `OCaml_4_07_1 | `OCaml_4_08_0 | `OCaml_4_09_0 | `OCaml_4_10_0 | `OCaml_4_11_0 | `OCaml_4_12_0 | `OCaml_4_13_0 - | `OCaml_4_14_0 ] = %s + | `OCaml_4_14_0 | `OCaml_5_0_0 | `OCaml_5_1_0 | `OCaml_5_2_0 ] = %s |} ocaml_version_val diff --git a/src/dot-merlin/dot_merlin_reader.ml b/src/dot-merlin/dot_merlin_reader.ml index e3a1aaba00..7fd2fff19d 100644 --- a/src/dot-merlin/dot_merlin_reader.ml +++ b/src/dot-merlin/dot_merlin_reader.ml @@ -72,8 +72,12 @@ module Cache = File_cache.Make (struct else if String.is_prefixed ~by:"B " line then tell (`B (String.drop 2 line)) + else if String.is_prefixed ~by:"BH " line then + tell (`BH (String.drop 3 line)) else if String.is_prefixed ~by:"S " line then tell (`S (String.drop 2 line)) + else if String.is_prefixed ~by:"SH " line then + tell (`SH (String.drop 3 line)) else if String.is_prefixed ~by:"SRC " line then tell (`S (String.drop 4 line)) else if String.is_prefixed ~by:"CMI " line then @@ -324,7 +328,7 @@ let empty_config = { let prepend_config ~cwd ~cfg = List.fold_left ~init:cfg ~f:(fun cfg (d : Merlin_dot_protocol.Directive.Raw.t) -> match d with - | `B _ | `S _ | `CMI _ | `CMT _ as directive -> + | `B _ | `S _ | `BH _ | `SH _ | `CMI _ | `CMT _ as directive -> { cfg with to_canonicalize = (cwd, directive) :: cfg.to_canonicalize } | `EXT _ | `SUFFIX _ | `FLG _ | `READER _ | (`EXCLUDE_QUERY_DIR | `USE_PPX_CACHE | `UNKNOWN_TAG _) as directive -> @@ -453,6 +457,8 @@ let postprocess cfg = match directive with | `B path -> List.map (expand ~stdlib dir path) ~f:(fun p -> `B p) | `S path -> List.map (expand ~stdlib dir path) ~f:(fun p -> `S p) + | `BH path -> List.map (expand ~stdlib dir path) ~f:(fun p -> `BH p) + | `SH path -> List.map (expand ~stdlib dir path) ~f:(fun p -> `SH p) | `CMI path -> List.map (expand ~stdlib dir path) ~f:(fun p -> `CMI p) | `CMT path -> List.map (expand ~stdlib dir path) ~f:(fun p -> `CMT p) in diff --git a/src/dot-protocol/merlin_dot_protocol.ml b/src/dot-protocol/merlin_dot_protocol.ml index 97648d9317..6798632b68 100644 --- a/src/dot-protocol/merlin_dot_protocol.ml +++ b/src/dot-protocol/merlin_dot_protocol.ml @@ -31,7 +31,12 @@ open Merlin_utils.Std.Result module Directive = struct type include_path = - [ `B of string | `S of string | `CMI of string | `CMT of string ] + [ `B of string + | `S of string + | `BH of string + | `SH of string + | `CMI of string + | `CMT of string ] type no_processing_required = [ `EXT of string list @@ -82,6 +87,8 @@ module Sexp = struct begin match tag with | "S" -> `S value | "B" -> `B value + | "SH" -> `SH value + | "BH" -> `BH value | "CMI" -> `CMI value | "CMT" -> `CMT value | "STDLIB" -> `STDLIB value @@ -112,6 +119,8 @@ module Sexp = struct match t with | `B s -> ("B", single s) | `S s -> ("S", single s) + | `BH s -> ("BH", single s) + | `SH s -> ("SH", single s) | `CMI s -> ("CMI", single s) | `CMT s -> ("CMT", single s) | `EXT ss -> ("EXT", [ List (atoms_of_strings ss) ]) diff --git a/src/dot-protocol/merlin_dot_protocol.mli b/src/dot-protocol/merlin_dot_protocol.mli index c238b813ae..96e34972d2 100644 --- a/src/dot-protocol/merlin_dot_protocol.mli +++ b/src/dot-protocol/merlin_dot_protocol.mli @@ -43,7 +43,12 @@ really do not want to load them. *) module Directive : sig type include_path = - [ `B of string | `S of string | `CMI of string | `CMT of string ] + [ `B of string + | `S of string + | `BH of string + | `SH of string + | `CMI of string + | `CMT of string ] type no_processing_required = [ `EXT of string list diff --git a/src/frontend/dune b/src/frontend/dune index 92776fa4f2..c5597f13f9 100644 --- a/src/frontend/dune +++ b/src/frontend/dune @@ -29,4 +29,5 @@ merlin_specific merlin_config merlin_analysis - query_protocol)) + query_protocol + str)) diff --git a/src/frontend/ocamlmerlin/dune b/src/frontend/ocamlmerlin/dune index e8ab3eccdd..629faa6e4b 100644 --- a/src/frontend/ocamlmerlin/dune +++ b/src/frontend/ocamlmerlin/dune @@ -17,7 +17,7 @@ (libraries merlin-lib.config yojson merlin-lib.analysis merlin-lib.kernel merlin-lib.utils merlin-lib.os_ipc merlin-lib.ocaml_parsing merlin-lib.query_protocol merlin-lib.query_commands - merlin-lib.ocaml_typing merlin-lib.ocaml_utils)) + merlin-lib.ocaml_typing merlin-lib.ocaml_utils unix str)) (executable (name gen_ccflags) diff --git a/src/frontend/query_commands.ml b/src/frontend/query_commands.ml index 350d3e7586..e5b1518ffd 100644 --- a/src/frontend/query_commands.ml +++ b/src/frontend/query_commands.ml @@ -204,18 +204,9 @@ let dump pipeline = function let reconstruct_identifier pipeline pos = function | None -> - let path = Mreader.reconstruct_identifier - (Mpipeline.input_config pipeline) - (Mpipeline.raw_source pipeline) - pos - in - let path = Mreader_lexer.identifier_suffix path in - Logger.log - ~section:Type_enclosing.log_section - ~title:"reconstruct-identifier" - "paths: [%s]" - (String.concat ~sep:";" (List.map path - ~f:(fun l -> l.Location.txt))); + let config = Mpipeline.input_config pipeline in + let source = Mpipeline.raw_source pipeline in + let path = Misc_utils.parse_identifier (config, source) pos in let reify dot = if dot = "" || (dot.[0] >= 'a' && dot.[0] <= 'z') || @@ -362,7 +353,8 @@ let dispatch pipeline (type a) : a Query_protocol.t -> a = | Locate_type pos -> let typer = Mpipeline.typer_result pipeline in - let structures = Mbrowse.of_typedtree (Mtyper.get_typedtree typer) in + let local_defs = Mtyper.get_typedtree typer in + let structures = Mbrowse.of_typedtree local_defs in let pos = Mpipeline.get_lexing_pos pipeline pos in let node = match Mbrowse.enclosing pos [structures] with @@ -388,15 +380,22 @@ let dispatch pipeline (type a) : a Query_protocol.t -> a = | None -> `Invalid_context | Some (env, path) -> Locate.log ~title:"debug" "found type: %s" (Path.name path); + let config = Locate.{ + mconfig = Mpipeline.final_config pipeline; + ml_or_mli = `MLI; + traverse_aliases = true + } + in match Locate.from_path + ~config ~env - ~config:(Mpipeline.final_config pipeline) - ~namespace:`Type `MLI + ~local_defs + ~namespace:Type path with - | `Builtin -> `Builtin (Path.name path) + | `Builtin (_, s) -> `Builtin s | `Not_in_env _ as s -> s | `Not_found _ as s -> s - | `Found (_uid, file, pos) -> `Found (file, pos) + | `Found { file; location; _ } -> `Found (Some file, location.loc_start) | `File_not_found _ as s -> s end @@ -529,19 +528,24 @@ let dispatch pipeline (type a) : a Query_protocol.t -> a = path in if path = "" then `Invalid_context else - begin match - Locate.from_string - ~config:(Mpipeline.final_config pipeline) - ~env ~local_defs ~pos ml_or_mli path - with - | `Found (_, file, pos) -> + let config = Locate.{ + mconfig = Mpipeline.final_config pipeline; + ml_or_mli; + traverse_aliases = true + } + in + begin match Locate.from_string ~config ~env ~local_defs ~pos path with + | `Found { file; location; _ } -> Locate.log ~title:"result" - "found: %s" (Option.value ~default:"" file); - `Found (file, pos) + "found: %s" file; + `Found (Some file, location.loc_start) | `Missing_labels_namespace -> (* Can't happen because we haven't passed a namespace as input. *) assert false - | (`Not_found _|`At_origin |`Not_in_env _|`File_not_found _|`Builtin _) as + | `Builtin (_, s) -> + Locate.log ~title:"result" "found builtin %s" s; + `Builtin s + | (`Not_found _|`At_origin |`Not_in_env _|`File_not_found _) as otherwise -> Locate.log ~title:"result" "not found"; otherwise @@ -755,9 +759,9 @@ let dispatch pipeline (type a) : a Query_protocol.t -> a = | [] -> raise Not_found | x :: xs -> try - find_in_path_uncap (Mconfig.source_path config) x + find_in_path_normalized (Mconfig.source_path config) x with Not_found -> try - find_in_path_uncap (Mconfig.build_path config) x + find_in_path_normalized (Mconfig.build_path config) x with Not_found -> aux xs in @@ -785,68 +789,33 @@ let dispatch pipeline (type a) : a Query_protocol.t -> a = | Path_list `Build -> let config = Mpipeline.final_config pipeline in - Mconfig.(config.merlin.build_path) + Mconfig.(config.merlin.build_path @ config.merlin.hidden_build_path) | Path_list `Source -> let config = Mpipeline.final_config pipeline in - Mconfig.(config.merlin.source_path) + Mconfig.(config.merlin.source_path @ config.merlin.hidden_source_path) - | Occurrences (`Ident_at pos, _scope) -> - let typer = Mpipeline.typer_result pipeline in - let str = Mbrowse.of_typedtree (Mtyper.get_typedtree typer) in + | Occurrences (`Ident_at pos, _) -> + let config = Mpipeline.final_config pipeline in + let source = Mpipeline.raw_source pipeline in + let typer_result = Mpipeline.typer_result pipeline in let pos = Mpipeline.get_lexing_pos pipeline pos in - let enclosing = Mbrowse.enclosing pos [str] in - let curr_node = - let is_wildcard_pat = function - | Browse_raw.Pattern {pat_desc = Typedtree.Tpat_any; _} -> true - | _ -> false - in - List.find_some enclosing ~f:(fun (_, node) -> - (* it doesn't make sense to find occurrences of a wildcard pattern *) - not (is_wildcard_pat node)) - |> Option.map ~f:(fun (env, node) -> Browse_tree.of_node ~env node) - |> Option.value ~default:Browse_tree.dummy - in - let str = Browse_tree.of_browse str in - let get_loc {Location.txt = _; loc} = loc in - let ident_occurrence () = - let paths = Browse_raw.node_paths curr_node.Browse_tree.t_node in - let under_cursor p = Location_aux.compare_pos pos (get_loc p) = 0 in - Logger.log ~section:"occurrences" ~title:"Occurrences paths" "%a" - Logger.json (fun () -> - let dump_path ({Location.txt; loc} as p) = - let ppf, to_string = Format.to_string () in - Printtyp.path ppf txt; - `Assoc [ - "start", Lexing.json_of_position loc.Location.loc_start; - "end", Lexing.json_of_position loc.Location.loc_end; - "under_cursor", `Bool (under_cursor p); - "path", `String (to_string ()) - ] - in - `List (List.map ~f:dump_path paths)); - match List.filter paths ~f:under_cursor with - | [] -> [] - | (path :: _) -> - let path = path.Location.txt in - let ts = Browse_tree.all_occurrences path str in - let loc (_t,paths) = List.map ~f:get_loc paths in - List.concat_map ~f:loc ts - - in - let constructor_occurrence d = - let ts = Browse_tree.all_constructor_occurrences (curr_node,d) str in - List.map ~f:get_loc ts - + let env, _node = Mbrowse.leaf_node (Mtyper.node_at typer_result pos) in + let path = + let path = reconstruct_identifier pipeline pos None in + let path = Mreader_lexer.identifier_suffix path in + let path = List.map ~f:(fun {Location. txt; _} -> txt) path in + let path = String.concat ~sep:"." path in + Locate.log ~title:"reconstructed identifier" "%s" path; + path in let locs = - match Browse_raw.node_is_constructor curr_node.Browse_tree.t_node with - | Some d -> constructor_occurrence d.Location.txt - | None -> ident_occurrence () + Occurrences.locs_of ~config ~source ~env ~typer_result ~pos path + |> Result.value ~default:[] in let loc_start l = l.Location.loc_start in let cmp l1 l2 = Lexing.compare_pos (loc_start l1) (loc_start l2) in - List.sort ~cmp locs + (List.sort ~cmp locs) | Version -> Printf.sprintf "The Merlin toolkit version %s, for Ocaml %s\n" diff --git a/src/kernel/dune b/src/kernel/dune index af69229174..7d12d85e73 100644 --- a/src/kernel/dune +++ b/src/kernel/dune @@ -13,8 +13,9 @@ -open Ocaml_typing -open Merlin_specific -open Merlin_extend) - (libraries merlin_config os_ipc ocaml_parsing ocaml_preprocess ocaml_typing ocaml_utils - merlin_extend merlin_specific merlin_utils merlin_dot_protocol)) + (libraries merlin_config os_ipc ocaml_parsing ocaml_preprocess ocaml_typing + ocaml_utils merlin_extend merlin_specific merlin_utils + merlin_dot_protocol unix str)) (rule (targets standard_library.ml) diff --git a/src/kernel/extension.ml b/src/kernel/extension.ml index 91a08cdd53..cd9173a191 100644 --- a/src/kernel/extension.ml +++ b/src/kernel/extension.ml @@ -46,33 +46,6 @@ type set = string list let ident = Ident.create_persistent "_" (** Definition of each extension *) -let ext_lwt = { - name = "lwt"; - private_def = [ - "module Lwt : sig - val un_lwt : 'a Lwt.t -> 'a - val in_lwt : 'a Lwt.t -> 'a Lwt.t - val to_lwt : 'a -> 'a Lwt.t - val finally' : 'a Lwt.t -> unit Lwt.t -> 'a Lwt.t - val un_stream : 'a Lwt_stream.t -> 'a - val unit_lwt : unit Lwt.t -> unit Lwt.t - end" - ]; - public_def = [ - "val (>>) : unit Lwt.t -> 'a Lwt.t -> 'a Lwt.t - val raise_lwt : exn -> 'a Lwt.t - val assert_lwt : bool -> unit Lwt.t" - ]; - keywords = [ - "lwt", LET_LWT; - "try_lwt", TRY_LWT; - "match_lwt", MATCH_LWT; - "finally", FINALLY_LWT; - "for_lwt", FOR_LWT; - "while_lwt", WHILE_LWT; - ]; - packages = ["lwt.syntax"]; -} let ext_nonrec = { name = "nonrec"; @@ -100,7 +73,7 @@ let ext_meta = { } (* Known extensions *) -let registry = [ext_lwt;ext_meta] +let registry = [ext_meta] let registry = List.fold_left registry ~init:String.Map.empty ~f:(fun map ext -> String.Map.add map ~key:ext.name ~data:ext) diff --git a/src/kernel/mconfig.ml b/src/kernel/mconfig.ml index e050014f92..0ec794d370 100644 --- a/src/kernel/mconfig.ml +++ b/src/kernel/mconfig.ml @@ -6,6 +6,7 @@ let {Logger. log} = Logger.for_section "Mconfig" type ocaml = { include_dirs : string list; + hidden_dirs : string list; no_std_include : bool; unsafe : bool; classic : bool; @@ -15,7 +16,6 @@ type ocaml = { recursive_types : bool; strict_sequence : bool; applicative_functors : bool; - unsafe_string : bool; nopervasives : bool; strict_formats : bool; open_modules : string list; @@ -32,6 +32,7 @@ let dump_warnings st = let dump_ocaml x = `Assoc [ "include_dirs" , `List (List.map ~f:Json.string x.include_dirs); + "hidden_dirs" , `List (List.map ~f:Json.string x.hidden_dirs); "no_std_include" , `Bool x.no_std_include; "unsafe" , `Bool x.unsafe; "classic" , `Bool x.classic; @@ -40,7 +41,6 @@ let dump_ocaml x = `Assoc [ "recursive_types" , `Bool x.recursive_types; "strict_sequence" , `Bool x.strict_sequence; "applicative_functors" , `Bool x.applicative_functors; - "unsafe_string" , `Bool x.unsafe_string; "nopervasives" , `Bool x.nopervasives; "strict_formats" , `Bool x.strict_formats; "open_modules" , Json.list Json.string x.open_modules; @@ -72,6 +72,8 @@ let marg_commandline f = type merlin = { build_path : string list; source_path : string list; + hidden_build_path : string list; + hidden_source_path : string list; cmi_path : string list; cmt_path : string list; extensions : string list; @@ -104,6 +106,8 @@ let dump_merlin x = `Assoc [ "build_path" , `List (List.map ~f:Json.string x.build_path); "source_path" , `List (List.map ~f:Json.string x.source_path); + "hidden_build_path" , `List (List.map ~f:Json.string x.hidden_build_path); + "hidden_source_path", `List (List.map ~f:Json.string x.hidden_source_path); "cmi_path" , `List (List.map ~f:Json.string x.cmi_path); "cmt_path" , `List (List.map ~f:Json.string x.cmt_path); "flags_applied", `List (List.map ~f:dump_flag_list x.flags_applied); @@ -236,8 +240,8 @@ let merge_merlin_config dot merlin ~failures ~config_path = { merlin with build_path = dot.Mconfig_dot.build_path @ merlin.build_path; source_path = dot.source_path @ merlin.source_path; - cmi_path = dot.cmi_path @ merlin.cmi_path; - cmt_path = dot.cmt_path @ merlin.cmt_path; + hidden_build_path = dot.hidden_build_path @ merlin.hidden_build_path; + hidden_source_path = dot.hidden_source_path @ merlin.hidden_source_path; exclude_query_dir = dot.exclude_query_dir || merlin.exclude_query_dir; use_ppx_cache = dot.use_ppx_cache || merlin.use_ppx_cache; extensions = dot.extensions @ merlin.extensions; @@ -275,6 +279,18 @@ let merlin_flags = [ {merlin with source_path = dir :: merlin.source_path}), " Add to merlin source path" ); + ( + "-hidden-build-path", + marg_path (fun dir merlin -> + {merlin with hidden_build_path = dir :: merlin.hidden_build_path}), + " Add to merlin hidden build path" + ); + ( + "-hidden-source-path", + marg_path (fun dir merlin -> + {merlin with hidden_source_path = dir :: merlin.hidden_source_path}), + " Add to merlin hidden source path" + ); ( "-cmi-path", marg_path (fun dir merlin -> @@ -430,7 +446,7 @@ let ocaml_ignored_parametrized_flags = [ "-inline"; "-inline-prim-cost"; "-inline-toplevel"; "-intf"; "-intf_suffix"; "-intf-suffix"; "-o"; "-rounds"; "-runtime-variant"; "-unbox-closures-factor"; "-use-prims"; "-use_runtime"; "-use-runtime"; - "-error-style"; "-dump-dir"; + "-error-style"; "-dump-dir"; "-cmi-file"; ] let ocaml_warnings_spec ~error = @@ -458,6 +474,13 @@ let ocaml_flags = [ {ocaml with include_dirs = dir :: ocaml.include_dirs}), " Add to the list of include directories" ); + ( + "-H", + marg_path (fun dir ocaml -> + {ocaml with hidden_dirs = dir :: ocaml.hidden_dirs}), + " Add to the list of \"hidden\" include directories\n\ + \ (Like -I, but the program can not directly reference these dependencies)" + ); ( "-nostdlib", Marg.unit (fun ocaml -> {ocaml with no_std_include = true}), @@ -518,19 +541,10 @@ let ocaml_flags = [ Marg.unit (fun ocaml -> {ocaml with threads = `None}), " Add support for VM-scheduled threads library" ); - ( - "-unsafe-string", - Marg.unit (fun ocaml -> {ocaml with unsafe_string = true}), - Printf.sprintf - " Make strings mutable (default: %B)" - (not Config.safe_string) - ); ( "-safe-string", - Marg.unit (fun ocaml -> {ocaml with unsafe_string = false}), - Printf.sprintf - " Make strings immutable (default: %B)" - Config.safe_string + Marg.unit (fun ocaml -> ocaml), + " Default to true unconditionally since 5.00" ); ( "-nopervasives", @@ -599,6 +613,7 @@ let ocaml_flags = [ let initial = { ocaml = { include_dirs = []; + hidden_dirs = []; no_std_include = false; unsafe = false; classic = false; @@ -608,7 +623,6 @@ let initial = { recursive_types = false; strict_sequence = false; applicative_functors = true; - unsafe_string = not Config.safe_string; nopervasives = false; strict_formats = false; open_modules = []; @@ -619,6 +633,8 @@ let initial = { merlin = { build_path = []; source_path = []; + hidden_build_path = []; + hidden_source_path = []; cmi_path = []; cmt_path = []; extensions = []; @@ -732,7 +748,8 @@ let source_path config = List.concat [[config.query.directory]; stdlib; - config.merlin.source_path] + config.merlin.source_path; + config.merlin.hidden_source_path] |> List.filter_dup let build_path config = ( @@ -764,6 +781,9 @@ let build_path config = ( result' ) +let hidden_build_path config = + config.merlin.hidden_build_path @ config.ocaml.hidden_dirs + let cmt_path config = ( let dirs = match config.ocaml.threads with @@ -774,6 +794,7 @@ let cmt_path config = ( let dirs = config.merlin.cmt_path @ config.merlin.build_path @ + config.merlin.hidden_build_path @ dirs in let stdlib = stdlib config in diff --git a/src/kernel/mconfig.mli b/src/kernel/mconfig.mli index 05d3197f23..0111f6c125 100644 --- a/src/kernel/mconfig.mli +++ b/src/kernel/mconfig.mli @@ -4,6 +4,7 @@ open Std type ocaml = { include_dirs : string list; + hidden_dirs : string list; no_std_include : bool; unsafe : bool; classic : bool; @@ -13,7 +14,6 @@ type ocaml = { recursive_types : bool; strict_sequence : bool; applicative_functors : bool; - unsafe_string : bool; nopervasives : bool; strict_formats : bool; open_modules : string list; @@ -30,6 +30,8 @@ val dump_ocaml : ocaml -> json type merlin = { build_path : string list; source_path : string list; + hidden_build_path : string list; + hidden_source_path : string list; cmi_path : string list; cmt_path : string list; extensions : string list; @@ -57,7 +59,7 @@ val dump_merlin : merlin -> json (** {1 Some flags affecting queries} *) -module Verbosity : sig +module Verbosity : sig type t = Smart | Lvl of int (** the default value for verbosity, i.e., [Lvl 0] *) @@ -114,6 +116,8 @@ val source_path : t -> string list val build_path : t -> string list +val hidden_build_path : t -> string list + val cmt_path : t -> string list val global_modules : ?include_current:bool -> t -> string list diff --git a/src/kernel/mconfig_dot.ml b/src/kernel/mconfig_dot.ml index 13ad8eba99..a5303f7a53 100644 --- a/src/kernel/mconfig_dot.ml +++ b/src/kernel/mconfig_dot.ml @@ -35,6 +35,8 @@ type directive = Merlin_dot_protocol.directive type config = { build_path : string list; source_path : string list; + hidden_build_path : string list; + hidden_source_path : string list; cmi_path : string list; cmt_path : string list; flags : string list with_workdir list; @@ -48,6 +50,8 @@ type config = { let empty_config = { build_path = []; + hidden_build_path =[]; + hidden_source_path = []; source_path = []; cmi_path = []; cmt_path = []; @@ -235,6 +239,8 @@ let prepend_config ~dir:cwd configurator (directives : directive list) config = function | `B path -> {config with build_path = path :: config.build_path}, errors | `S path -> {config with source_path = path :: config.source_path}, errors + | `BH path -> {config with hidden_build_path = path :: config.hidden_build_path}, errors + | `SH path -> {config with hidden_source_path = path :: config.hidden_source_path}, errors | `CMI path -> {config with cmi_path = path :: config.cmi_path}, errors | `CMT path -> {config with cmt_path = path :: config.cmt_path}, errors | `EXT exts -> @@ -268,6 +274,8 @@ let postprocess_config config = { build_path = clean config.build_path; source_path = clean config.source_path; + hidden_build_path = clean config.hidden_build_path; + hidden_source_path = clean config.hidden_source_path; cmi_path = clean config.cmi_path; cmt_path = clean config.cmt_path; extensions = clean config.extensions; diff --git a/src/kernel/mconfig_dot.mli b/src/kernel/mconfig_dot.mli index 926fb928a8..b31f31b36f 100644 --- a/src/kernel/mconfig_dot.mli +++ b/src/kernel/mconfig_dot.mli @@ -37,6 +37,8 @@ end type config = { build_path : string list; source_path : string list; + hidden_build_path : string list; + hidden_source_path : string list; cmi_path : string list; cmt_path : string list; flags : string list with_workdir list; diff --git a/src/kernel/mocaml.ml b/src/kernel/mocaml.ml index 6b4cd38dc9..95f87afc24 100644 --- a/src/kernel/mocaml.ml +++ b/src/kernel/mocaml.ml @@ -39,7 +39,6 @@ let setup_reader_config config = ( recursive_types := ocaml.recursive_types ; strict_sequence := ocaml.strict_sequence ; applicative_functors := ocaml.applicative_functors ; - unsafe_string := ocaml.unsafe_string ; nopervasives := ocaml.nopervasives ; strict_formats := ocaml.strict_formats ; open_modules := ocaml.open_modules ; @@ -47,7 +46,9 @@ let setup_reader_config config = ( let setup_typer_config config = ( setup_reader_config config; - Load_path.init (Mconfig.build_path config); + let visible = Mconfig.build_path config in + let hidden = Mconfig.hidden_build_path config in + Load_path.(init ~auto_include:no_auto_include ~visible ~hidden); ) (** Switchable implementation of Oprint *) diff --git a/src/kernel/mppx.ml b/src/kernel/mppx.ml index 4e1fea6002..43bb0f0d1c 100644 --- a/src/kernel/mppx.ml +++ b/src/kernel/mppx.ml @@ -2,10 +2,15 @@ open Mconfig let {Logger. log} = Logger.for_section "Mppx" -let with_include_dir path f = - let saved = !Clflags.include_dirs in - let restore () = Clflags.include_dirs := saved in - Clflags.include_dirs := path; +let with_include_dir ~visible_path ~hidden_path f = + let saved_visible = !Clflags.include_dirs in + let saved_hidden = !Clflags.hidden_include_dirs in + let restore () = + Clflags.include_dirs := saved_visible; + Clflags.hidden_include_dirs := saved_hidden + in + Clflags.include_dirs := visible_path; + Clflags.hidden_include_dirs := hidden_path; let result = begin try @@ -22,7 +27,10 @@ let with_include_dir path f = let rewrite parsetree cfg = let ppx = cfg.ocaml.ppx in (* add include path attribute to the parsetree *) - with_include_dir (Mconfig.build_path cfg) @@ fun () -> + with_include_dir + ~visible_path:(Mconfig.build_path cfg) + ~hidden_path:(Mconfig.hidden_build_path cfg) + @@ fun () -> match Pparse.apply_rewriters ~restore:false ~ppx ~tool_name:"merlin" parsetree with diff --git a/src/kernel/mtyper.ml b/src/kernel/mtyper.ml index 034cb10c7d..3b4b72db7d 100644 --- a/src/kernel/mtyper.ml +++ b/src/kernel/mtyper.ml @@ -47,6 +47,7 @@ type result = { initial_env : Env.t; initial_snapshot : Types.snapshot; initial_stamp : int; + stamp : int; typedtree : [ | `Interface of (Parsetree.signature_item, Typedtree.signature_item) item list @@ -155,11 +156,11 @@ let run config parsetree = if not (Env.check_state_consistency ()) then ( (* Resetting the local store will clear the load_path cache. Save it now, reset the store and then restore the path. *) - let load_path = Load_path.get_paths () in + let { Load_path.visible; hidden } = Load_path.get_paths () in Mocaml.flush_caches (); Local_store.reset (); Load_path.reset (); - Load_path.init load_path; + Load_path.(init ~auto_include:no_auto_include ~visible ~hidden); ); let caught = ref [] in Msupport.catch_errors Mconfig.(config.ocaml.warnings) caught @@ fun () -> @@ -168,8 +169,9 @@ let run config parsetree = | `Implementation parsetree -> type_implementation config caught parsetree | `Interface parsetree -> type_interface config caught parsetree in + let stamp = Ident.get_currentstamp () in Typecore.reset_delayed_checks (); - { config; initial_env; initial_snapshot; initial_stamp; typedtree; cache_stat } + { config; initial_env; initial_snapshot; initial_stamp; stamp; typedtree; cache_stat } let get_env ?pos:_ t = Option.value ~default:t.initial_env ( @@ -206,6 +208,8 @@ let get_typedtree t = let sig_items, sig_type = split_items l in `Interface {Typedtree. sig_items; sig_type; sig_final_env = get_env t} +let get_stamp t = t.stamp + let node_at ?(skip_recovered=false) t pos_cursor = let node = Mbrowse.of_typedtree (get_typedtree t) in log ~title:"node_at" "Node: %s" (Mbrowse.print () node); diff --git a/src/kernel/mtyper.mli b/src/kernel/mtyper.mli index fd6a7a6b77..58cedd9582 100644 --- a/src/kernel/mtyper.mli +++ b/src/kernel/mtyper.mli @@ -22,6 +22,8 @@ val get_env : ?pos:Msource.position -> result -> Env.t val get_typedtree : result -> typedtree +val get_stamp : result -> int + val get_errors : result -> exn list val initial_env : result -> Env.t diff --git a/src/ocaml/compression/dune b/src/ocaml/compression/dune new file mode 100644 index 0000000000..86c7f02108 --- /dev/null +++ b/src/ocaml/compression/dune @@ -0,0 +1,4 @@ +(library + (name ocaml_compression) + (public_name merlin-lib.ocaml_compression) + (libraries compiler-libs.common)) diff --git a/src/ocaml/compression/ocaml_compression.ml b/src/ocaml/compression/ocaml_compression.ml new file mode 100644 index 0000000000..464aa32bd3 --- /dev/null +++ b/src/ocaml/compression/ocaml_compression.ml @@ -0,0 +1,3 @@ + +(** We rely on [compiler-libs] for compression *) +include Compression diff --git a/src/ocaml/merlin_specific/browse_raw.ml b/src/ocaml/merlin_specific/browse_raw.ml index 88caa4bed6..4d6fe4ac7c 100644 --- a/src/ocaml/merlin_specific/browse_raw.ml +++ b/src/ocaml/merlin_specific/browse_raw.ml @@ -299,7 +299,7 @@ let of_pat_record_field obj loc lbl = let of_pattern_desc (type k) (desc : k pattern_desc) = match desc with | Tpat_any | Tpat_var _ | Tpat_constant _ | Tpat_variant (_,None,_) -> id_fold - | Tpat_alias (p,_,_) | Tpat_variant (_,Some p,_) | Tpat_lazy p + | Tpat_alias (p,_,_,_) | Tpat_variant (_,Some p,_) | Tpat_lazy p | Tpat_exception p -> of_pattern p | Tpat_value p -> of_pattern (p :> value general_pattern) | Tpat_tuple ps | Tpat_construct (_,_,ps,None) | Tpat_array ps -> @@ -319,13 +319,13 @@ let of_method_call obj meth loc = let loc = {loc with Location. loc_start; loc_end} in app (Method_call (obj,meth,loc)) env f acc -let of_expression_desc loc = function +let rec of_expression_desc loc = function | Texp_ident _ | Texp_constant _ | Texp_instvar _ | Texp_variant (_,None) | Texp_new _ | Texp_hole -> id_fold | Texp_let (_,vbs,e) -> of_expression e ** list_fold of_value_binding vbs - | Texp_function { cases; _ } -> - list_fold of_case cases + | Texp_function (params, body) -> + list_fold of_function_param params ** of_function_body body | Texp_apply (e,ls) -> of_expression e ** list_fold (function @@ -341,7 +341,7 @@ let of_expression_desc loc = function | Texp_tuple es | Texp_construct (_,_,es) | Texp_array es -> list_fold of_expression es | Texp_variant (_,Some e) - | Texp_assert e | Texp_lazy e | Texp_setinstvar (_,_,_,e) -> + | Texp_assert (e, _) | Texp_lazy e | Texp_setinstvar (_,_,_,e) -> of_expression e | Texp_record { fields; extended_expression } -> option_fold of_expression extended_expression ** @@ -368,7 +368,7 @@ let of_expression_desc loc = function | Texp_letmodule (mb_id, mb_name, mb_presence, mb_expr, e) -> let mb = {mb_id;mb_name;mb_expr;mb_loc=Location.none;mb_attributes=[] - ; mb_presence } + ; mb_presence; mb_uid=Shape.Uid.internal_not_actually_unique } in app (Module_binding mb) ** of_expression e | Texp_letexception (ec,e) -> @@ -398,6 +398,17 @@ let of_expression_desc loc = function | Texp_open (od, e) -> app (Module_expr od.open_expr) ** of_expression e +and of_function_param fp = of_function_param_kind fp.fp_kind + +and of_function_param_kind = function + | Tparam_pat pat -> of_pattern pat + | Tparam_optional_default (pat, exp) -> + of_pattern pat ** of_expression exp + +and of_function_body = function + | Tfunction_body exp -> of_expression exp + | Tfunction_cases fc -> list_fold of_case fc.cases + and of_class_expr_desc = function | Tcl_ident (_,_,cts) -> list_fold of_core_type cts @@ -445,6 +456,8 @@ and of_module_expr_desc = function | Tmod_apply (me1,me2,_) -> of_module_expr me1 ** of_module_expr me2 + | Tmod_apply_unit (me1) -> + of_module_expr me1 | Tmod_constraint (me,_,mtc,_) -> of_module_expr me ** app (Module_type_constraint mtc) @@ -532,6 +545,7 @@ and of_signature_item_desc = function and of_core_type_desc = function | Ttyp_any | Ttyp_var _ -> id_fold + | Ttyp_open (_,_,ct) -> of_core_type ct | Ttyp_arrow (_,ct1,ct2) -> of_core_type ct1 ** of_core_type ct2 | Ttyp_tuple cts | Ttyp_constr (_,_,cts) | Ttyp_class (_,_,cts) -> @@ -778,9 +792,9 @@ let pattern_paths (type k) { Typedtree. pat_desc; pat_extra; _ } = match (pat_desc : k pattern_desc) with | Tpat_construct (lid_loc,{Types. cstr_name; cstr_res; _},_,_) -> fake_path lid_loc cstr_res cstr_name - | Tpat_var (id, {Location. loc; txt}) -> + | Tpat_var (id, {Location. loc; txt}, _uid) -> [mkloc (Path.Pident id) loc, Some (Longident.Lident txt)] - | Tpat_alias (_,id,loc) -> + | Tpat_alias (_,id,loc, _uid) -> [reloc (Path.Pident id) loc, Some (Longident.Lident loc.txt)] | _ -> [] in @@ -834,7 +848,7 @@ let expression_paths { Typedtree. exp_desc; exp_extra; _ } = List.fold_left ~init exp_extra ~f:(fun acc (extra, _, _) -> match extra with - | Texp_newtype' (id, label_loc) -> + | Texp_newtype' (id, label_loc, _) -> let path = Path.Pident id in let lid = Longident.Lident (label_loc.txt) in (mkloc path label_loc.loc, Some lid) :: acc diff --git a/src/ocaml/merlin_specific/tast_helper.ml b/src/ocaml/merlin_specific/tast_helper.ml index 1664fa1586..d9dead492b 100644 --- a/src/ocaml/merlin_specific/tast_helper.ml +++ b/src/ocaml/merlin_specific/tast_helper.ml @@ -8,13 +8,13 @@ module Pat = struct let pat_desc = Tpat_constant c in { pat_desc; pat_loc = loc; pat_extra; pat_attributes; pat_type; pat_env } - let var ?loc pat_env pat_type str = + let var ?loc uid pat_env pat_type str = let pat_loc = match loc with | None -> str.Asttypes.loc | Some loc -> loc in - let pat_desc = Tpat_var (Ident.create_local str.Asttypes.txt, str) in + let pat_desc = Tpat_var (Ident.create_local str.Asttypes.txt, str, uid) in { pat_desc; pat_loc; pat_extra; pat_attributes; pat_type; pat_env } let record ?(loc=Location.none) pat_env pat_type lst closed_flag = @@ -25,7 +25,7 @@ module Pat = struct let pat_desc = Tpat_tuple lst in { pat_desc; pat_loc = loc; pat_extra; pat_attributes; pat_type; pat_env } - let construct ?(loc=Location.none) + let construct ?(loc=Location.none) pat_env pat_type lid cstr_desc args locs_coretype = let pat_desc = Tpat_construct (lid, cstr_desc, args, locs_coretype) in { pat_desc; pat_loc = loc; pat_extra; pat_attributes; pat_type; pat_env } diff --git a/src/ocaml/merlin_specific/typer_raw.ml b/src/ocaml/merlin_specific/typer_raw.ml index 0d83b8b20c..26926f6688 100644 --- a/src/ocaml/merlin_specific/typer_raw.ml +++ b/src/ocaml/merlin_specific/typer_raw.ml @@ -27,8 +27,6 @@ )* }}} *) open Std -open Location -open Parsetree let fresh_env () = (*Ident.reinit();*) @@ -40,552 +38,5 @@ let fresh_env () = in Typemod.initial_env ~loc:(Location.in_file "command line") - ~safe_string:(not !Clflags.unsafe_string) ~initially_opened_module ~open_implicit_modules:(List.rev !Clflags.open_modules) - -module Rewrite_loc = struct - let queue = ref [] - - let update l = - if l <> none then - match !queue with - | [] -> assert false - | l' :: ls -> queue := Location_aux.union l l' :: ls - - let enter () = queue := Location.none :: !queue - let leave l0 = match !queue with - | [] -> assert false - | [l] -> queue := []; Location_aux.extend l0 l - | l :: l' :: ls -> - let l = Location_aux.extend l0 l in - queue := Location_aux.union l l' :: ls; - l - - let start () = assert (!queue = []); enter () - let exit () = match !queue with - | [_] -> queue := [] - | _ -> assert false - - let u_option f = function - | None -> None - | Some x -> Some (f x) - - let u_loc (loc : _ Location.loc) = - update loc.loc; loc - - let rec u_attribute { attr_name = loc ; attr_payload; attr_loc } = - let loc = if Location_aux.is_relaxed_location loc then loc else u_loc loc in - { attr_name = loc - ; attr_payload = u_payload attr_payload - ; attr_loc } - - and u_extension (loc, payload) = - let loc = if Location_aux.is_relaxed_location loc then loc else u_loc loc in - (loc, u_payload payload) - - and u_attributes l = List.map ~f:u_attribute l - - and u_payload = function - | PStr str -> PStr (u_structure str) - | PSig sg -> PSig (u_signature sg) - | PTyp ct -> PTyp (u_core_type ct) - | PPat (p, eo) -> PPat (u_pattern p, u_option u_expression eo) - - and u_core_type {ptyp_desc; ptyp_attributes; ptyp_loc; ptyp_loc_stack} = - enter (); - let ptyp_desc = u_core_type_desc ptyp_desc in - let ptyp_attributes = u_attributes ptyp_attributes in - let ptyp_loc = leave ptyp_loc in - {ptyp_desc; ptyp_loc; ptyp_attributes; ptyp_loc_stack} - - and u_core_type_desc = function - | Ptyp_any | Ptyp_var _ as desc -> desc - | Ptyp_arrow (l, t1, t2) -> Ptyp_arrow (l, u_core_type t1, u_core_type t2) - | Ptyp_tuple ts -> Ptyp_tuple (List.map ~f:u_core_type ts) - | Ptyp_constr (loc, ts) -> Ptyp_constr (u_loc loc, List.map ~f:u_core_type ts) - | Ptyp_object (fields, flag) -> - let object_field_desc = function - | Otag (lbl, ct) -> Otag (lbl, u_core_type ct) - | Oinherit ct -> Oinherit (u_core_type ct) - in - let object_field { pof_desc; pof_loc; pof_attributes } = - { pof_desc = object_field_desc pof_desc - ; pof_attributes = u_attributes pof_attributes - ; pof_loc } - in - Ptyp_object (List.map ~f:object_field fields, flag) - | Ptyp_class (loc, ts) -> Ptyp_class (u_loc loc, List.map ~f:u_core_type ts) - | Ptyp_alias (ct, name) -> Ptyp_alias (u_core_type ct, name) - | Ptyp_variant (fields, flag, label) -> Ptyp_variant (List.map ~f:u_row_field fields, flag, label) - | Ptyp_poly (ss,ct) -> Ptyp_poly (ss, u_core_type ct) - | Ptyp_package pt -> Ptyp_package (u_package_type pt) - | Ptyp_extension ext -> Ptyp_extension (u_extension ext) - - and u_package_type (loc, cts) = - (u_loc loc, List.map ~f:(fun (l,ct) -> u_loc l, u_core_type ct) cts) - - and u_row_field { prf_desc; prf_loc; prf_attributes } = - let desc = function - | Rtag (l,has_const,cts) -> - Rtag (l, has_const, List.map ~f:u_core_type cts) - | Rinherit ct -> Rinherit (u_core_type ct) - in - { prf_desc = desc prf_desc - ; prf_loc - ; prf_attributes = u_attributes prf_attributes } - - and u_pattern {ppat_desc; ppat_loc; ppat_attributes; ppat_loc_stack} = - enter (); - let ppat_desc = u_pattern_desc ppat_desc in - let ppat_attributes = u_attributes ppat_attributes in - let ppat_loc = leave ppat_loc in - {ppat_desc; ppat_loc; ppat_attributes; ppat_loc_stack} - - and u_pattern_desc = function - | Ppat_any | Ppat_constant _ | Ppat_interval _ as p -> p - | Ppat_var l -> Ppat_var (u_loc l) - | Ppat_alias (p, l) -> Ppat_alias (u_pattern p, u_loc l) - | Ppat_tuple ps -> Ppat_tuple (List.map ~f:u_pattern ps) - | Ppat_construct (loc, po) -> Ppat_construct (u_loc loc, u_option - (fun (locs, p) -> locs, u_pattern p) po) - | Ppat_variant (lbl, po) -> Ppat_variant (lbl, u_option u_pattern po) - | Ppat_record (fields, flag) -> Ppat_record (List.map ~f:(fun (l,p) -> (u_loc l, u_pattern p)) fields, flag) - | Ppat_array ps -> Ppat_array (List.map ~f:u_pattern ps) - | Ppat_or (p1, p2) -> Ppat_or (u_pattern p1, u_pattern p2) - | Ppat_constraint (p, ct) -> Ppat_constraint (u_pattern p, u_core_type ct) - | Ppat_type loc -> Ppat_type (u_loc loc) - | Ppat_lazy p -> Ppat_lazy (u_pattern p) - | Ppat_unpack loc -> Ppat_unpack (u_loc loc) - | Ppat_exception p -> Ppat_exception (u_pattern p) - | Ppat_extension ext -> Ppat_extension (u_extension ext) - | Ppat_open (l,p) -> Ppat_open (u_loc l, u_pattern p) - - and u_expression {pexp_desc; pexp_loc; pexp_attributes; pexp_loc_stack} = - enter (); - let pexp_desc = u_expression_desc pexp_desc in - let pexp_attributes = u_attributes pexp_attributes in - let pexp_loc = leave pexp_loc in - {pexp_desc; pexp_loc; pexp_attributes; pexp_loc_stack} - - and u_expression_desc = function - | Pexp_ident loc -> Pexp_ident (u_loc loc) - | Pexp_constant _ as e -> e - | Pexp_let (flag, vs, e) -> - Pexp_let (flag, List.map ~f:u_value_binding vs, u_expression e) - | Pexp_function cs -> - Pexp_function (List.map ~f:u_case cs) - | Pexp_fun (lbl, eo, pattern, expr) -> - Pexp_fun (lbl, u_option u_expression eo, u_pattern pattern, u_expression expr) - | Pexp_apply (e, les) -> - Pexp_apply (u_expression e, List.map ~f:(fun (l,e) -> (l, u_expression e)) les) - | Pexp_match (e, cs) -> Pexp_match (u_expression e, List.map ~f:u_case cs) - | Pexp_try (e, cs) -> Pexp_try (u_expression e, List.map ~f:u_case cs) - | Pexp_tuple es -> Pexp_tuple (List.map ~f:u_expression es) - | Pexp_construct (loc, eo) -> - Pexp_construct (u_loc loc, u_option u_expression eo) - | Pexp_variant (lbl, eo) -> - Pexp_variant (lbl, u_option u_expression eo) - | Pexp_record (les, eo) -> - Pexp_record (List.map ~f:(fun (loc,e) -> (u_loc loc, u_expression e)) les, u_option u_expression eo) - | Pexp_field (e, loc) -> Pexp_field (u_expression e, u_loc loc) - | Pexp_setfield (e1, loc, e2) -> Pexp_setfield (u_expression e1, u_loc loc, u_expression e2) - | Pexp_array es -> Pexp_array (List.map ~f:u_expression es) - | Pexp_ifthenelse (e1,e2,e3) -> Pexp_ifthenelse (u_expression e1, u_expression e2, u_option u_expression e3) - | Pexp_sequence (e1, e2) -> Pexp_sequence (u_expression e1, u_expression e2) - | Pexp_while (e1, e2) -> Pexp_while (u_expression e1, u_expression e2) - | Pexp_for (p, e1, e2, flag, e3) -> Pexp_for (u_pattern p, u_expression e1, u_expression e2, flag, u_expression e3) - | Pexp_constraint (e, ct) -> Pexp_constraint (u_expression e, u_core_type ct) - | Pexp_coerce (e, cto, ct) -> Pexp_coerce (u_expression e, u_option u_core_type cto, u_core_type ct) - | Pexp_send (e, s) -> Pexp_send (u_expression e, s) - | Pexp_new loc -> Pexp_new (u_loc loc) - | Pexp_setinstvar (s, e) -> Pexp_setinstvar (u_loc s, u_expression e) - | Pexp_override es -> Pexp_override (List.map ~f:(fun (loc,e) -> (u_loc loc, u_expression e)) es) - | Pexp_letmodule (s, me, e) -> Pexp_letmodule (u_loc s, u_module_expr me, u_expression e) - | Pexp_letexception (c, e) -> Pexp_letexception (u_extension_constructor c, u_expression e) - | Pexp_assert e -> Pexp_assert (u_expression e) - | Pexp_lazy e -> Pexp_lazy (u_expression e) - | Pexp_poly (e, cto) -> Pexp_poly (u_expression e, u_option u_core_type cto) - | Pexp_object cs -> Pexp_object (u_class_structure cs) - | Pexp_newtype (s, e) -> Pexp_newtype (s, u_expression e) - | Pexp_pack me -> Pexp_pack (u_module_expr me) - | Pexp_open (od, e) -> Pexp_open (u_open_declaration od, u_expression e) - | Pexp_extension ext -> Pexp_extension (u_extension ext) - | Pexp_unreachable -> Pexp_unreachable - | Pexp_letop { let_; ands; body } -> - Pexp_letop { - let_ = u_binding_op let_; - ands = List.map ~f:u_binding_op ands; - body = u_expression body; - } - - and u_binding_op { pbop_op; pbop_pat; pbop_exp; pbop_loc } = - { pbop_op = u_loc pbop_op - ; pbop_pat = u_pattern pbop_pat - ; pbop_exp = u_expression pbop_exp - ; pbop_loc } - - and u_case {pc_lhs; pc_guard; pc_rhs} = { - pc_lhs = u_pattern pc_lhs; - pc_guard = u_option u_expression pc_guard; - pc_rhs = u_expression pc_rhs; - } - - and u_value_description {pval_name; pval_type; pval_prim; pval_attributes; pval_loc} = - enter (); - let pval_name = u_loc pval_name in - let pval_type = u_core_type pval_type in - let pval_attributes = u_attributes pval_attributes in - let pval_loc = leave pval_loc in - {pval_name; pval_type; pval_prim; pval_attributes; pval_loc} - - and u_type_declaration {ptype_name; ptype_params; ptype_cstrs; ptype_kind; - ptype_private; ptype_manifest; ptype_attributes; ptype_loc} = - enter (); - let ptype_name = u_loc ptype_name - and ptype_params = List.map ~f:(fun (ct,v) -> (u_core_type ct, v)) ptype_params - and ptype_cstrs = List.map ~f:(fun (ct1,ct2,l) -> - update l; (u_core_type ct1, u_core_type ct2, l)) ptype_cstrs - and ptype_kind = u_type_kind ptype_kind - and ptype_manifest = u_option u_core_type ptype_manifest - and ptype_attributes = u_attributes ptype_attributes - in - let ptype_loc = leave ptype_loc in - {ptype_name; ptype_params; ptype_cstrs; ptype_kind; - ptype_private; ptype_manifest; ptype_attributes; ptype_loc} - - and u_type_kind = function - | Ptype_abstract | Ptype_open as k -> k - | Ptype_variant cstrs -> Ptype_variant (List.map ~f:u_constructor_declaration cstrs) - | Ptype_record lbls -> Ptype_record (List.map ~f:u_label_declaration lbls) - - and u_label_declaration {pld_name; pld_mutable; pld_type; pld_loc; pld_attributes} = - enter (); - let pld_name = u_loc pld_name in - let pld_type = u_core_type pld_type in - let pld_attributes = u_attributes pld_attributes in - let pld_loc = leave pld_loc in - {pld_name; pld_mutable; pld_type; pld_loc; pld_attributes} - - and u_constructor_declaration {pcd_name; pcd_vars; pcd_args; pcd_res; pcd_loc; pcd_attributes} = - enter (); - let pcd_name = u_loc pcd_name in - let pcd_vars = List.map ~f:u_loc pcd_vars in - let pcd_args = u_constructor_arguments pcd_args in - let pcd_res = u_option u_core_type pcd_res in - let pcd_attributes = u_attributes pcd_attributes in - let pcd_loc = leave pcd_loc in - {pcd_name; pcd_vars; pcd_args; pcd_res; pcd_loc; pcd_attributes} - - and u_constructor_arguments = function - | Pcstr_tuple cts -> Pcstr_tuple (List.map ~f:u_core_type cts) - | Pcstr_record lbls -> Pcstr_record (List.map ~f:u_label_declaration lbls) - - and u_type_extension - {ptyext_path; ptyext_params; ptyext_constructors; ptyext_private - ; ptyext_attributes; ptyext_loc } = - let ptyext_path = u_loc ptyext_path in - let ptyext_params = List.map ~f:(fun (ct,v) -> (u_core_type ct, v)) ptyext_params in - let ptyext_constructors = List.map ~f:u_extension_constructor ptyext_constructors in - let ptyext_attributes = u_attributes ptyext_attributes in - {ptyext_path; ptyext_params; ptyext_constructors; ptyext_private - ; ptyext_attributes; ptyext_loc } - - and u_extension_constructor {pext_name; pext_kind; pext_loc; pext_attributes} = - enter (); - let pext_name = u_loc pext_name in - let pext_kind = u_extension_constructor_kind pext_kind in - let pext_attributes = u_attributes pext_attributes in - let pext_loc = leave pext_loc in - {pext_name; pext_kind; pext_loc; pext_attributes} - - and u_extension_constructor_kind = function - | Pext_decl (locs, cargs, cto) -> - Pext_decl (List.map ~f:u_loc locs, - u_constructor_arguments cargs, - u_option u_core_type cto) - | Pext_rebind loc -> Pext_rebind (u_loc loc) - - (** {2 Class language} *) - - (* Type expressions for the class language *) - - and u_class_type {pcty_desc; pcty_loc; pcty_attributes} = - enter (); - let pcty_desc = u_class_type_desc pcty_desc in - let pcty_attributes = u_attributes pcty_attributes in - let pcty_loc = leave pcty_loc in - {pcty_desc; pcty_loc; pcty_attributes} - - and u_class_type_desc = function - | Pcty_constr (loc, cts) -> - Pcty_constr (u_loc loc, List.map ~f:u_core_type cts) - | Pcty_signature cs -> Pcty_signature (u_class_signature cs) - | Pcty_arrow (lbl, ct, clt) -> - Pcty_arrow (lbl, u_core_type ct, u_class_type clt) - | Pcty_extension ext -> - Pcty_extension (u_extension ext) - | Pcty_open (od, cty) -> - Pcty_open (u_open_description od, u_class_type cty) - - and u_class_signature {pcsig_self; pcsig_fields} = - let pcsig_self = u_core_type pcsig_self in - let pcsig_fields = List.map ~f:u_class_type_field pcsig_fields in - {pcsig_self; pcsig_fields} - - and u_class_type_field {pctf_desc; pctf_loc; pctf_attributes} = - enter (); - let pctf_desc = u_class_type_field_desc pctf_desc in - let pctf_attributes = u_attributes pctf_attributes in - let pctf_loc = leave pctf_loc in - {pctf_desc; pctf_loc; pctf_attributes} - - and u_class_type_field_desc = function - | Pctf_inherit clt -> Pctf_inherit (u_class_type clt) - | Pctf_val (s, fl1, fl2, ct) -> Pctf_val (s, fl1, fl2, u_core_type ct) - | Pctf_method (s, fl1, fl2, ct) -> Pctf_method (s, fl1, fl2, u_core_type ct) - | Pctf_constraint (ct1, ct2) -> Pctf_constraint (u_core_type ct1, u_core_type ct2) - | Pctf_attribute attr -> - Pctf_attribute (u_attribute attr) - | Pctf_extension ext -> Pctf_extension (u_extension ext) - - and u_class_infos : 'a 'b. ('a -> 'b) -> 'a class_infos -> 'b class_infos = - fun u_a {pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes} -> - enter (); - let pci_params = List.map ~f:(fun (ct,v) -> (u_core_type ct, v)) pci_params in - let pci_name = u_loc pci_name in - let pci_expr = u_a pci_expr in - let pci_attributes = u_attributes pci_attributes in - let pci_loc = leave pci_loc in - {pci_virt; pci_params; pci_name; pci_expr; pci_loc; pci_attributes} - - and u_class_description clt = u_class_infos u_class_type clt - - and u_class_type_declaration clt = u_class_infos u_class_type clt - - and u_class_expr {pcl_desc; pcl_loc; pcl_attributes} = - enter (); - let pcl_desc = u_class_expr_desc pcl_desc in - let pcl_attributes = u_attributes pcl_attributes in - let pcl_loc = leave pcl_loc in - {pcl_desc; pcl_loc; pcl_attributes} - - and u_class_expr_desc = function - | Pcl_constr (loc, cts) -> Pcl_constr (u_loc loc, List.map ~f:u_core_type cts) - | Pcl_structure cs -> Pcl_structure (u_class_structure cs) - | Pcl_fun (lbl, eo, p, ce) -> - Pcl_fun (lbl, u_option u_expression eo, u_pattern p, u_class_expr ce) - | Pcl_apply (ce, les) -> - Pcl_apply (u_class_expr ce, List.map ~f:(fun (l,e) -> (l, u_expression e)) les) - | Pcl_let (rf, vbs, ce) -> - Pcl_let (rf, List.map ~f:u_value_binding vbs, u_class_expr ce) - | Pcl_constraint (ce, ct) -> Pcl_constraint (u_class_expr ce, u_class_type ct) - | Pcl_extension ext -> Pcl_extension (u_extension ext) - | Pcl_open (od, ce) -> - Pcl_open (u_open_description od, u_class_expr ce) - - and u_class_structure {pcstr_self; pcstr_fields} = - let pcstr_self = u_pattern pcstr_self in - let pcstr_fields = List.map ~f:u_class_field pcstr_fields in - {pcstr_self; pcstr_fields} - - and u_class_field {pcf_desc; pcf_loc; pcf_attributes} = - enter (); - let pcf_desc = u_class_field_desc pcf_desc in - let pcf_attributes = u_attributes pcf_attributes in - let pcf_loc = leave pcf_loc in - {pcf_desc; pcf_loc; pcf_attributes} - - and u_class_field_desc = function - | Pcf_inherit (fl, ce, so) -> Pcf_inherit (fl, u_class_expr ce, so) - | Pcf_val (loc, fl, cfk) -> Pcf_val (u_loc loc, fl, u_class_field_kind cfk) - | Pcf_method (loc, fl, cfk) -> Pcf_method (u_loc loc, fl, u_class_field_kind cfk) - | Pcf_constraint (c1, c2) -> Pcf_constraint (u_core_type c1, u_core_type c2) - | Pcf_initializer e -> Pcf_initializer (u_expression e) - | Pcf_attribute attr -> Pcf_attribute (u_attribute attr) - | Pcf_extension ext -> Pcf_extension (u_extension ext) - - and u_class_field_kind = function - | Cfk_virtual ct -> Cfk_virtual (u_core_type ct) - | Cfk_concrete (fl,e) -> Cfk_concrete (fl, u_expression e) - - and u_class_declaration cd = u_class_infos u_class_expr cd - - and u_module_type {pmty_desc; pmty_loc; pmty_attributes} = - enter (); - let pmty_desc = u_module_type_desc pmty_desc in - let pmty_attributes = u_attributes pmty_attributes in - let pmty_loc = leave pmty_loc in - {pmty_desc; pmty_loc; pmty_attributes} - - and u_module_type_desc = function - | Pmty_ident loc -> Pmty_ident (u_loc loc) - | Pmty_signature sg -> Pmty_signature (u_signature sg) - | Pmty_functor (fp, mt) -> Pmty_functor (u_functor_parameter fp, u_module_type mt) - | Pmty_with (mt, wts) -> Pmty_with (u_module_type mt, List.map ~f:u_with_constraint wts) - | Pmty_typeof me -> Pmty_typeof (u_module_expr me) - | Pmty_extension ext -> Pmty_extension (u_extension ext) - | Pmty_alias loc -> Pmty_alias (u_loc loc) - - and u_functor_parameter = function - | Unit -> Unit - | Named (name, mt) -> Named (u_loc name, u_module_type mt) - - and u_signature l = List.map ~f:u_signature_item l - - and u_signature_item {psig_desc; psig_loc} = - enter (); - let psig_desc = u_signature_item_desc psig_desc in - let psig_loc = leave psig_loc in - {psig_desc; psig_loc} - - and u_signature_item_desc = function - | Psig_value vd -> Psig_value (u_value_description vd) - | Psig_type (fl, tds) -> Psig_type (fl, List.map ~f:u_type_declaration tds) - | Psig_typext text -> Psig_typext (u_type_extension text) - | Psig_exception texn -> Psig_exception (u_type_exception texn) - | Psig_module md -> Psig_module (u_module_declaration md) - | Psig_recmodule mds -> Psig_recmodule (List.map ~f:u_module_declaration mds) - | Psig_modtype mtd -> Psig_modtype (u_module_type_declaration mtd) - | Psig_open od -> Psig_open (u_open_description od) - | Psig_include id -> Psig_include (u_include_description id) - | Psig_class cds -> Psig_class (List.map ~f:u_class_description cds) - | Psig_class_type cts -> Psig_class_type (List.map ~f:u_class_type_declaration cts) - | Psig_attribute attr -> Psig_attribute (u_attribute attr) - | Psig_extension (ext, attrs) -> Psig_extension (u_extension ext, u_attributes attrs) - | Psig_typesubst tds -> Psig_typesubst (List.map ~f:u_type_declaration tds) - | Psig_modsubst ms -> Psig_modsubst (u_module_substitution ms) - | Psig_modtypesubst mtd -> Psig_modtype (u_module_type_declaration mtd) - - and u_type_exception {ptyexn_constructor; ptyexn_loc; ptyexn_attributes } = - { ptyexn_constructor = u_extension_constructor ptyexn_constructor - ; ptyexn_loc - ; ptyexn_attributes = u_attributes ptyexn_attributes } - - and u_module_declaration {pmd_name; pmd_type; pmd_attributes; pmd_loc} = - enter (); - let pmd_name = u_loc pmd_name in - let pmd_type = u_module_type pmd_type in - let pmd_attributes = u_attributes pmd_attributes in - let pmd_loc = leave pmd_loc in - {pmd_name; pmd_type; pmd_attributes; pmd_loc} - - and u_module_substitution {pms_name; pms_manifest; pms_attributes; pms_loc} = - let pms_name = u_loc pms_name in - let pms_manifest = u_loc pms_manifest in - let pms_attributes = u_attributes pms_attributes in - { pms_name; pms_manifest; pms_attributes; pms_loc } - - and u_module_type_declaration {pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc} = - enter (); - let pmtd_name = u_loc pmtd_name in - let pmtd_type = u_option u_module_type pmtd_type in - let pmtd_attributes = u_attributes pmtd_attributes in - let pmtd_loc = leave pmtd_loc in - {pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc} - - and u_open_declaration {popen_expr; popen_override; popen_loc; popen_attributes} = - enter (); - let popen_expr = u_module_expr popen_expr in - let popen_attributes = u_attributes popen_attributes in - let popen_loc = leave popen_loc in - {popen_expr; popen_override; popen_loc; popen_attributes} - - and u_open_description {popen_expr; popen_override; popen_loc; popen_attributes} = - enter (); - let popen_expr = u_loc popen_expr in - let popen_attributes = u_attributes popen_attributes in - let popen_loc = leave popen_loc in - {popen_expr; popen_override; popen_loc; popen_attributes} - - and u_include_infos : 'a 'b . ('a -> 'b) -> 'a include_infos -> 'b include_infos = - fun u_a {pincl_mod; pincl_loc; pincl_attributes} -> - enter (); - let pincl_mod = u_a pincl_mod in - let pincl_attributes = u_attributes pincl_attributes in - let pincl_loc = leave pincl_loc in - {pincl_mod; pincl_loc; pincl_attributes} - - and u_include_description id = u_include_infos u_module_type id - and u_include_declaration id = u_include_infos u_module_expr id - - and u_with_constraint = function - | Pwith_type (loc, td) -> Pwith_type (u_loc loc, u_type_declaration td) - | Pwith_module (loc1, loc2) -> Pwith_module (u_loc loc1, u_loc loc2) - | Pwith_typesubst (loc, td) -> - Pwith_typesubst (u_loc loc, u_type_declaration td) - | Pwith_modsubst (loc1, loc2) -> Pwith_modsubst (u_loc loc1, u_loc loc2) - | Pwith_modtype (loc, mt) -> Pwith_modtype (u_loc loc, u_module_type mt) - | Pwith_modtypesubst (loc, mt) -> - Pwith_modtypesubst (u_loc loc, u_module_type mt) - - and u_module_expr {pmod_desc; pmod_loc; pmod_attributes} = - enter (); - let pmod_desc = u_module_expr_desc pmod_desc in - let pmod_attributes = u_attributes pmod_attributes in - let pmod_loc = leave pmod_loc in - {pmod_desc; pmod_loc; pmod_attributes} - - and u_module_expr_desc = function - | Pmod_ident loc -> Pmod_ident (u_loc loc) - | Pmod_structure str -> Pmod_structure (u_structure str) - | Pmod_functor (fp, me) -> - Pmod_functor (u_functor_parameter fp, u_module_expr me) - | Pmod_apply (me1, me2) -> - Pmod_apply (u_module_expr me1, u_module_expr me2) - | Pmod_constraint (me, mt) -> - Pmod_constraint (u_module_expr me, u_module_type mt) - | Pmod_unpack e -> Pmod_unpack (u_expression e) - | Pmod_extension ext -> Pmod_extension (u_extension ext) - - and u_structure l = List.map ~f:u_structure_item l - - and u_structure_item {pstr_desc; pstr_loc} = - enter (); - let pstr_desc = u_structure_item_desc pstr_desc in - let pstr_loc = leave pstr_loc in - {pstr_desc; pstr_loc} - - and u_structure_item_desc = function - | Pstr_eval (expr, attrs) -> Pstr_eval (u_expression expr, u_attributes attrs) - | Pstr_value (fl, vbs) -> Pstr_value (fl, List.map ~f:u_value_binding vbs) - | Pstr_primitive vd -> Pstr_primitive (u_value_description vd) - | Pstr_type (fl, tds) -> Pstr_type (fl, List.map ~f:u_type_declaration tds) - | Pstr_typext text -> Pstr_typext (u_type_extension text) - | Pstr_exception texn -> Pstr_exception (u_type_exception texn) - | Pstr_module mb -> Pstr_module (u_module_binding mb) - | Pstr_recmodule mbs -> Pstr_recmodule (List.map ~f:u_module_binding mbs) - | Pstr_modtype mtd -> Pstr_modtype (u_module_type_declaration mtd) - | Pstr_open od -> Pstr_open (u_open_declaration od) - | Pstr_class cds -> Pstr_class (List.map ~f:u_class_declaration cds) - | Pstr_class_type ctds -> Pstr_class_type (List.map ~f:u_class_type_declaration ctds) - | Pstr_include id -> Pstr_include (u_include_declaration id) - | Pstr_attribute attr -> Pstr_attribute (u_attribute attr) - | Pstr_extension (ext, attrs) -> Pstr_extension (u_extension ext, u_attributes attrs) - - and u_value_binding {pvb_pat; pvb_expr; pvb_attributes; pvb_loc} = - enter (); - let pvb_pat = u_pattern pvb_pat in - let pvb_expr = u_expression pvb_expr in - let pvb_attributes = u_attributes pvb_attributes in - let pvb_loc = leave pvb_loc in - {pvb_pat; pvb_expr; pvb_attributes; pvb_loc} - - and u_module_binding {pmb_name; pmb_expr; pmb_attributes; pmb_loc} = - enter (); - let pmb_name = u_loc pmb_name in - let pmb_expr = u_module_expr pmb_expr in - let pmb_attributes = u_attributes pmb_attributes in - let pmb_loc = leave pmb_loc in - {pmb_name; pmb_expr; pmb_attributes; pmb_loc} -end - -let rewrite_loc t = - Rewrite_loc.start (); - let t = match t with - | `str str -> `str (Rewrite_loc.u_structure str) - | `fake str -> `fake (Rewrite_loc.u_structure str) - | `sg sg -> `sg (Rewrite_loc.u_signature sg) - in - Rewrite_loc.exit (); - t diff --git a/src/ocaml/merlin_specific/typer_raw.mli b/src/ocaml/merlin_specific/typer_raw.mli index 669bdf1dd7..b6550aa7b6 100644 --- a/src/ocaml/merlin_specific/typer_raw.mli +++ b/src/ocaml/merlin_specific/typer_raw.mli @@ -27,9 +27,3 @@ )* }}} *) val fresh_env : unit -> Env.t - -val rewrite_loc : - [ `str of Parsetree.structure | `sg of Parsetree.signature - | `fake of Parsetree.structure ] -> - [ `str of Parsetree.structure | `sg of Parsetree.signature - | `fake of Parsetree.structure ] diff --git a/src/ocaml/parsing/ast_helper.ml b/src/ocaml/parsing/ast_helper.ml index 06a47bb48e..5e093022bc 100644 --- a/src/ocaml/parsing/ast_helper.ml +++ b/src/ocaml/parsing/ast_helper.ml @@ -77,6 +77,7 @@ module Typ = struct let poly ?loc ?attrs a b = mk ?loc ?attrs (Ptyp_poly (a, b)) let package ?loc ?attrs a b = mk ?loc ?attrs (Ptyp_package (a, b)) let extension ?loc ?attrs a = mk ?loc ?attrs (Ptyp_extension a) + let open_ ?loc ?attrs mod_ident t = mk ?loc ?attrs (Ptyp_open (mod_ident, t)) let force_poly t = match t.ptyp_desc with @@ -107,9 +108,9 @@ module Typ = struct Ptyp_object (List.map loop_object_field lst, o) | Ptyp_class (longident, lst) -> Ptyp_class (longident, List.map loop lst) - | Ptyp_alias(core_type, string) -> - check_variable var_names t.ptyp_loc string; - Ptyp_alias(loop core_type, string) + | Ptyp_alias(core_type, alias) -> + check_variable var_names alias.loc alias.txt; + Ptyp_alias(loop core_type, alias) | Ptyp_variant(row_field_list, flag, lbl_lst_option) -> Ptyp_variant(List.map loop_row_field row_field_list, flag, lbl_lst_option) @@ -119,6 +120,8 @@ module Typ = struct Ptyp_poly(string_lst, loop core_type) | Ptyp_package(longident,lst) -> Ptyp_package(longident,List.map (fun (n,typ) -> (n,loop typ) ) lst) + | Ptyp_open (mod_ident, core_type) -> + Ptyp_open (mod_ident, loop core_type) | Ptyp_extension (s, arg) -> Ptyp_extension (s, arg) in @@ -186,8 +189,7 @@ module Exp = struct let ident ?loc ?attrs a = mk ?loc ?attrs (Pexp_ident a) let constant ?loc ?attrs a = mk ?loc ?attrs (Pexp_constant a) let let_ ?loc ?attrs a b c = mk ?loc ?attrs (Pexp_let (a, b, c)) - let fun_ ?loc ?attrs a b c d = mk ?loc ?attrs (Pexp_fun (a, b, c, d)) - let function_ ?loc ?attrs a = mk ?loc ?attrs (Pexp_function a) + let function_ ?loc ?attrs a b c = mk ?loc ?attrs (Pexp_function (a, b, c)) let apply ?loc ?attrs a b = mk ?loc ?attrs (Pexp_apply (a, b)) let match_ ?loc ?attrs a b = mk ?loc ?attrs (Pexp_match (a, b)) let try_ ?loc ?attrs a b = mk ?loc ?attrs (Pexp_try (a, b)) @@ -259,8 +261,8 @@ module Mty = struct end module Mod = struct -let mk ?(loc = !default_loc) ?(attrs = []) d = - {pmod_desc = d; pmod_loc = loc; pmod_attributes = attrs} + let mk ?(loc = !default_loc) ?(attrs = []) d = + {pmod_desc = d; pmod_loc = loc; pmod_attributes = attrs} let attr d a = {d with pmod_attributes = d.pmod_attributes @ [a]} let ident ?loc ?attrs x = mk ?loc ?attrs (Pmod_ident x) @@ -268,6 +270,7 @@ let mk ?(loc = !default_loc) ?(attrs = []) d = let functor_ ?loc ?attrs arg body = mk ?loc ?attrs (Pmod_functor (arg, body)) let apply ?loc ?attrs m1 m2 = mk ?loc ?attrs (Pmod_apply (m1, m2)) + let apply_unit ?loc ?attrs m1 = mk ?loc ?attrs (Pmod_apply_unit m1) let constraint_ ?loc ?attrs m mty = mk ?loc ?attrs (Pmod_constraint (m, mty)) let unpack ?loc ?attrs e = mk ?loc ?attrs (Pmod_unpack e) let extension ?loc ?attrs a = mk ?loc ?attrs (Pmod_extension a) @@ -499,10 +502,11 @@ end module Vb = struct let mk ?(loc = !default_loc) ?(attrs = []) ?(docs = empty_docs) - ?(text = []) pat expr = + ?(text = []) ?value_constraint pat expr = { pvb_pat = pat; pvb_expr = expr; + pvb_constraint=value_constraint; pvb_attributes = add_text_attrs text (add_docs_attrs docs attrs); pvb_loc = loc; @@ -665,6 +669,7 @@ end type let_binding = { lb_pattern: pattern; lb_expression: expression; + lb_constraint: value_constraint option; lb_is_pun: bool; lb_attributes: attributes; lb_docs: docs Lazy.t; diff --git a/src/ocaml/parsing/ast_helper.mli b/src/ocaml/parsing/ast_helper.mli index cfa37629df..70f59e5b97 100644 --- a/src/ocaml/parsing/ast_helper.mli +++ b/src/ocaml/parsing/ast_helper.mli @@ -81,12 +81,14 @@ module Typ : val object_: ?loc:loc -> ?attrs:attrs -> object_field list -> closed_flag -> core_type val class_: ?loc:loc -> ?attrs:attrs -> lid -> core_type list -> core_type - val alias: ?loc:loc -> ?attrs:attrs -> core_type -> string -> core_type + val alias: ?loc:loc -> ?attrs:attrs -> core_type -> string with_loc + -> core_type val variant: ?loc:loc -> ?attrs:attrs -> row_field list -> closed_flag -> label list option -> core_type val poly: ?loc:loc -> ?attrs:attrs -> str list -> core_type -> core_type val package: ?loc:loc -> ?attrs:attrs -> lid -> (lid * core_type) list -> core_type + val open_ : ?loc:loc -> ?attrs:attrs -> lid -> core_type -> core_type val extension: ?loc:loc -> ?attrs:attrs -> extension -> core_type val force_poly: core_type -> core_type @@ -139,9 +141,9 @@ module Exp: val constant: ?loc:loc -> ?attrs:attrs -> constant -> expression val let_: ?loc:loc -> ?attrs:attrs -> rec_flag -> value_binding list -> expression -> expression - val fun_: ?loc:loc -> ?attrs:attrs -> arg_label -> expression option - -> pattern -> expression -> expression - val function_: ?loc:loc -> ?attrs:attrs -> case list -> expression + val function_ : ?loc:loc -> ?attrs:attrs -> function_param list + -> type_constraint option -> function_body + -> expression val apply: ?loc:loc -> ?attrs:attrs -> expression -> (arg_label * expression) list -> expression val match_: ?loc:loc -> ?attrs:attrs -> expression -> case list @@ -277,6 +279,7 @@ module Mod: functor_parameter -> module_expr -> module_expr val apply: ?loc:loc -> ?attrs:attrs -> module_expr -> module_expr -> module_expr + val apply_unit: ?loc:loc -> ?attrs:attrs -> module_expr -> module_expr val constraint_: ?loc:loc -> ?attrs:attrs -> module_expr -> module_type -> module_expr val unpack: ?loc:loc -> ?attrs:attrs -> expression -> module_expr @@ -376,7 +379,8 @@ module Incl: module Vb: sig val mk: ?loc: loc -> ?attrs:attrs -> ?docs:docs -> ?text:text -> - pattern -> expression -> value_binding + ?value_constraint:value_constraint -> pattern -> expression -> + value_binding end @@ -507,6 +511,7 @@ module Of: type let_binding = { lb_pattern: pattern; lb_expression: expression; + lb_constraint: value_constraint option; lb_is_pun: bool; lb_attributes: attributes; lb_docs: docs Lazy.t; diff --git a/src/ocaml/parsing/ast_iterator.ml b/src/ocaml/parsing/ast_iterator.ml index 468baedce0..94d5806fb3 100644 --- a/src/ocaml/parsing/ast_iterator.ml +++ b/src/ocaml/parsing/ast_iterator.ml @@ -40,6 +40,7 @@ type iterator = { class_type_declaration: iterator -> class_type_declaration -> unit; class_type_field: iterator -> class_type_field -> unit; constructor_declaration: iterator -> constructor_declaration -> unit; + directive_argument: iterator -> directive_argument -> unit; expr: iterator -> expression -> unit; extension: iterator -> extension -> unit; extension_constructor: iterator -> extension_constructor -> unit; @@ -61,6 +62,8 @@ type iterator = { signature_item: iterator -> signature_item -> unit; structure: iterator -> structure -> unit; structure_item: iterator -> structure_item -> unit; + toplevel_directive: iterator -> toplevel_directive -> unit; + toplevel_phrase: iterator -> toplevel_phrase -> unit; typ: iterator -> core_type -> unit; row_field: iterator -> row_field -> unit; object_field: iterator -> object_field -> unit; @@ -132,6 +135,9 @@ module T = struct | Ptyp_package (lid, l) -> iter_loc sub lid; List.iter (iter_tuple (iter_loc sub) (sub.typ sub)) l + | Ptyp_open (mod_ident, t) -> + iter_loc sub mod_ident; + sub.typ sub t | Ptyp_extension x -> sub.extension sub x let iter_type_declaration sub @@ -313,7 +319,10 @@ module M = struct iter_functor_param sub param; sub.module_expr sub body | Pmod_apply (m1, m2) -> - sub.module_expr sub m1; sub.module_expr sub m2 + sub.module_expr sub m1; + sub.module_expr sub m2 + | Pmod_apply_unit m1 -> + sub.module_expr sub m1 | Pmod_constraint (m, mty) -> sub.module_expr sub m; sub.module_type sub mty | Pmod_unpack e -> sub.expr sub e @@ -345,6 +354,32 @@ end module E = struct (* Value expressions for the core language *) + let iter_function_param sub { pparam_loc = loc; pparam_desc = desc } = + sub.location sub loc; + match desc with + | Pparam_val (_lab, def, p) -> + iter_opt (sub.expr sub) def; + sub.pat sub p + | Pparam_newtype ty -> + iter_loc sub ty + + let iter_body sub body = + match body with + | Pfunction_body e -> + sub.expr sub e + | Pfunction_cases (cases, loc, attrs) -> + sub.cases sub cases; + sub.location sub loc; + sub.attributes sub attrs + + let iter_constraint sub constraint_ = + match constraint_ with + | Pconstraint ty -> + sub.typ sub ty + | Pcoerce (ty1, ty2) -> + iter_opt (sub.typ sub) ty1; + sub.typ sub ty2 + let iter sub {pexp_loc = loc; pexp_desc = desc; pexp_attributes = attrs} = sub.location sub loc; sub.attributes sub attrs; @@ -354,11 +389,10 @@ module E = struct | Pexp_let (_r, vbs, e) -> List.iter (sub.value_binding sub) vbs; sub.expr sub e - | Pexp_fun (_lab, def, p, e) -> - iter_opt (sub.expr sub) def; - sub.pat sub p; - sub.expr sub e - | Pexp_function pel -> sub.cases sub pel + | Pexp_function (params, constraint_, body) -> + List.iter (iter_function_param sub) params; + iter_opt (iter_constraint sub) constraint_; + iter_body sub body | Pexp_apply (e, l) -> sub.expr sub e; List.iter (iter_snd (sub.expr sub)) l | Pexp_match (e, pel) -> @@ -632,9 +666,17 @@ let default_iterator = value_binding = - (fun this {pvb_pat; pvb_expr; pvb_attributes; pvb_loc} -> + (fun this {pvb_pat; pvb_expr; pvb_attributes; pvb_loc; pvb_constraint} -> this.pat this pvb_pat; this.expr this pvb_expr; + Option.iter (function + | Parsetree.Pvc_constraint {locally_abstract_univars=vars; typ} -> + List.iter (iter_loc this) vars; + this.typ this typ + | Pvc_coercion { ground; coercion } -> + Option.iter (this.typ this) ground; + this.typ this coercion; + ) pvb_constraint; this.location this pvb_loc; this.attributes this pvb_attributes ); @@ -683,4 +725,22 @@ let default_iterator = | PTyp x -> this.typ this x | PPat (x, g) -> this.pat this x; iter_opt (this.expr this) g ); + + directive_argument = + (fun this a -> + this.location this a.pdira_loc + ); + + toplevel_directive = + (fun this d -> + iter_loc this d.pdir_name; + iter_opt (this.directive_argument this) d.pdir_arg; + this.location this d.pdir_loc + ); + + toplevel_phrase = + (fun this -> function + | Ptop_def s -> this.structure this s + | Ptop_dir d -> this.toplevel_directive this d + ); } diff --git a/src/ocaml/parsing/ast_iterator.mli b/src/ocaml/parsing/ast_iterator.mli index 638ac5e8b6..6b02889163 100644 --- a/src/ocaml/parsing/ast_iterator.mli +++ b/src/ocaml/parsing/ast_iterator.mli @@ -43,6 +43,7 @@ type iterator = { class_type_declaration: iterator -> class_type_declaration -> unit; class_type_field: iterator -> class_type_field -> unit; constructor_declaration: iterator -> constructor_declaration -> unit; + directive_argument: iterator -> directive_argument -> unit; expr: iterator -> expression -> unit; extension: iterator -> extension -> unit; extension_constructor: iterator -> extension_constructor -> unit; @@ -64,6 +65,8 @@ type iterator = { signature_item: iterator -> signature_item -> unit; structure: iterator -> structure -> unit; structure_item: iterator -> structure_item -> unit; + toplevel_directive: iterator -> toplevel_directive -> unit; + toplevel_phrase: iterator -> toplevel_phrase -> unit; typ: iterator -> core_type -> unit; row_field: iterator -> row_field -> unit; object_field: iterator -> object_field -> unit; diff --git a/src/ocaml/parsing/ast_mapper.ml b/src/ocaml/parsing/ast_mapper.ml index 1a91863dd4..e3997095a9 100644 --- a/src/ocaml/parsing/ast_mapper.ml +++ b/src/ocaml/parsing/ast_mapper.ml @@ -20,6 +20,9 @@ (* Ensure that record patterns don't miss any field. *) *) +[@@@ocaml.warning "-60"] module Str = Ast_helper.Str (* For ocamldep *) +[@@@ocaml.warning "+60"] + open Parsetree open Ast_helper open Location @@ -45,6 +48,7 @@ type mapper = { constant: mapper -> constant -> constant; constructor_declaration: mapper -> constructor_declaration -> constructor_declaration; + directive_argument: mapper -> directive_argument -> directive_argument; expr: mapper -> expression -> expression; extension: mapper -> extension -> extension; extension_constructor: mapper -> extension_constructor @@ -68,6 +72,8 @@ type mapper = { signature_item: mapper -> signature_item -> signature_item; structure: mapper -> structure -> structure; structure_item: mapper -> structure_item -> structure_item; + toplevel_directive: mapper -> toplevel_directive -> toplevel_directive; + toplevel_phrase: mapper -> toplevel_phrase -> toplevel_phrase; typ: mapper -> core_type -> core_type; type_declaration: mapper -> type_declaration -> type_declaration; type_extension: mapper -> type_extension -> type_extension; @@ -144,7 +150,9 @@ module T = struct object_ ~loc ~attrs (List.map (object_field sub) l) o | Ptyp_class (lid, tl) -> class_ ~loc ~attrs (map_loc sub lid) (List.map (sub.typ sub) tl) - | Ptyp_alias (t, s) -> alias ~loc ~attrs (sub.typ sub t) s + | Ptyp_alias (t, s) -> + let s = map_loc sub s in + alias ~loc ~attrs (sub.typ sub t) s | Ptyp_variant (rl, b, ll) -> variant ~loc ~attrs (List.map (row_field sub) rl) b ll | Ptyp_poly (sl, t) -> poly ~loc ~attrs @@ -152,6 +160,8 @@ module T = struct | Ptyp_package (lid, l) -> package ~loc ~attrs (map_loc sub lid) (List.map (map_tuple (map_loc sub) (sub.typ sub)) l) + | Ptyp_open (mod_ident, t) -> + open_ ~loc ~attrs (map_loc sub mod_ident) (sub.typ sub t) | Ptyp_extension x -> extension ~loc ~attrs (sub.extension sub x) let map_type_declaration sub @@ -350,6 +360,8 @@ module M = struct (sub.module_expr sub body) | Pmod_apply (m1, m2) -> apply ~loc ~attrs (sub.module_expr sub m1) (sub.module_expr sub m2) + | Pmod_apply_unit m1 -> + apply_unit ~loc ~attrs (sub.module_expr sub m1) | Pmod_constraint (m, mty) -> constraint_ ~loc ~attrs (sub.module_expr sub m) (sub.module_type sub mty) @@ -385,6 +397,35 @@ end module E = struct (* Value expressions for the core language *) + let map_function_param sub { pparam_loc = loc; pparam_desc = desc } = + let loc = sub.location sub loc in + let desc = + match desc with + | Pparam_val (lab, def, p) -> + Pparam_val + (lab, + map_opt (sub.expr sub) def, + sub.pat sub p) + | Pparam_newtype ty -> + Pparam_newtype (map_loc sub ty) + in + { pparam_loc = loc; pparam_desc = desc } + + let map_function_body sub body = + match body with + | Pfunction_body e -> + Pfunction_body (sub.expr sub e) + | Pfunction_cases (cases, loc, attributes) -> + let cases = sub.cases sub cases in + let loc = sub.location sub loc in + let attributes = sub.attributes sub attributes in + Pfunction_cases (cases, loc, attributes) + + let map_constraint sub c = + match c with + | Pconstraint ty -> Pconstraint (sub.typ sub ty) + | Pcoerce (ty1, ty2) -> Pcoerce (map_opt (sub.typ sub) ty1, sub.typ sub ty2) + let map sub {pexp_loc = loc; pexp_desc = desc; pexp_attributes = attrs} = let open Exp in let loc = sub.location sub loc in @@ -395,10 +436,11 @@ module E = struct | Pexp_let (r, vbs, e) -> let_ ~loc ~attrs r (List.map (sub.value_binding sub) vbs) (sub.expr sub e) - | Pexp_fun (lab, def, p, e) -> - fun_ ~loc ~attrs lab (map_opt (sub.expr sub) def) (sub.pat sub p) - (sub.expr sub e) - | Pexp_function pel -> function_ ~loc ~attrs (sub.cases sub pel) + | Pexp_function (ps, c, b) -> + function_ ~loc ~attrs + (List.map (map_function_param sub) ps) + (map_opt (map_constraint sub) c) + (map_function_body sub b) | Pexp_apply (e, l) -> apply ~loc ~attrs (sub.expr sub e) (List.map (map_snd (sub.expr sub)) l) | Pexp_match (e, pel) -> @@ -691,10 +733,23 @@ let default_mapper = value_binding = - (fun this {pvb_pat; pvb_expr; pvb_attributes; pvb_loc} -> + (fun this {pvb_pat; pvb_expr; pvb_constraint; pvb_attributes; pvb_loc} -> + let map_ct (ct:Parsetree.value_constraint) = match ct with + | Pvc_constraint {locally_abstract_univars=vars; typ} -> + Pvc_constraint + { locally_abstract_univars = List.map (map_loc this) vars; + typ = this.typ this typ + } + | Pvc_coercion { ground; coercion } -> + Pvc_coercion { + ground = Option.map (this.typ this) ground; + coercion = this.typ this coercion + } + in Vb.mk (this.pat this pvb_pat) (this.expr this pvb_expr) + ?value_constraint:(Option.map map_ct pvb_constraint) ~loc:(this.location this pvb_loc) ~attrs:(this.attributes this pvb_attributes) ); @@ -752,6 +807,22 @@ let default_mapper = | PTyp x -> PTyp (this.typ this x) | PPat (x, g) -> PPat (this.pat this x, map_opt (this.expr this) g) ); + + directive_argument = + (fun this a -> + { pdira_desc= a.pdira_desc + ; pdira_loc= this.location this a.pdira_loc} ); + + toplevel_directive = + (fun this d -> + { pdir_name= map_loc this d.pdir_name + ; pdir_arg= map_opt (this.directive_argument this) d.pdir_arg + ; pdir_loc= this.location this d.pdir_loc } ); + + toplevel_phrase = + (fun this -> function + | Ptop_def s -> Ptop_def (this.structure this s) + | Ptop_dir d -> Ptop_dir (this.toplevel_directive this d) ); } let extension_of_error {kind; main; sub} = @@ -829,11 +900,16 @@ module PpxContext = struct } let make ~tool_name () = + let Load_path.{ visible; hidden } = Load_path.get_paths () in let fields = [ lid "tool_name", make_string tool_name; - lid "include_dirs", make_list make_string !Clflags.include_dirs; - lid "load_path", make_list make_string (Load_path.get_paths ()); + lid "include_dirs", make_list make_string (!Clflags.include_dirs); + lid "hidden_include_dirs", + make_list make_string (!Clflags.hidden_include_dirs); + lid "load_path", + make_pair (make_list make_string) (make_list make_string) + (visible, hidden); lid "open_modules", make_list make_string !Clflags.open_modules; lid "for_package", make_option make_string !Clflags.for_package; lid "debug", make_bool !Clflags.debug; @@ -843,7 +919,7 @@ module PpxContext = struct lid "principal", make_bool !Clflags.principal; lid "transparent_modules", make_bool !Clflags.transparent_modules; lid "unboxed_types", make_bool !Clflags.unboxed_types; - lid "unsafe_string", make_bool !Clflags.unsafe_string; + lid "unsafe_string", make_bool false; (* kept for compatibility *) get_cookies () ] in @@ -902,8 +978,23 @@ module PpxContext = struct tool_name_ref := get_string payload | "include_dirs" -> Clflags.include_dirs := get_list get_string payload + | "hidden_include_dirs" -> + Clflags.hidden_include_dirs := get_list get_string payload | "load_path" -> - Load_path.init (get_list get_string payload) + (* Duplicates Compmisc.auto_include, since we can't reference Compmisc + from this module. *) + (* let auto_include find_in_dir fn = + if !Clflags.no_std_include then + raise Not_found + else + let alert = Location.auto_include_alert in + Load_path.auto_include_otherlibs alert find_in_dir fn + in *) + let visible, hidden = + get_pair (get_list get_string) (get_list get_string) payload + in + let auto_include = Load_path.no_auto_include in + Load_path.init ~auto_include ~visible ~hidden | "open_modules" -> Clflags.open_modules := get_list get_string payload | "for_package" -> @@ -924,8 +1015,6 @@ module PpxContext = struct Clflags.transparent_modules := get_bool payload | "unboxed_types" -> Clflags.unboxed_types := get_bool payload - | "unsafe_string" -> - Clflags.unsafe_string := get_bool payload | "cookies" -> let l = get_list (get_pair get_string (fun x -> x)) payload in cookies := diff --git a/src/ocaml/parsing/ast_mapper.mli b/src/ocaml/parsing/ast_mapper.mli index 69f6b017ab..541c1f7dac 100644 --- a/src/ocaml/parsing/ast_mapper.mli +++ b/src/ocaml/parsing/ast_mapper.mli @@ -36,7 +36,7 @@ let test_mapper argv = expr = fun mapper expr -> match expr with | { pexp_desc = Pexp_extension ({ txt = "test" }, PStr [])} -> - Ast_helper.Exp.constant (Const_int 42) + Ast_helper.Exp.constant (Pconst_integer ("42", None)) | other -> default_mapper.expr mapper other; } let () = @@ -74,6 +74,7 @@ type mapper = { constant: mapper -> constant -> constant; constructor_declaration: mapper -> constructor_declaration -> constructor_declaration; + directive_argument: mapper -> directive_argument -> directive_argument; expr: mapper -> expression -> expression; extension: mapper -> extension -> extension; extension_constructor: mapper -> extension_constructor @@ -97,6 +98,8 @@ type mapper = { signature_item: mapper -> signature_item -> signature_item; structure: mapper -> structure -> structure; structure_item: mapper -> structure_item -> structure_item; + toplevel_directive: mapper -> toplevel_directive -> toplevel_directive; + toplevel_phrase: mapper -> toplevel_phrase -> toplevel_phrase; typ: mapper -> core_type -> core_type; type_declaration: mapper -> type_declaration -> type_declaration; type_extension: mapper -> type_extension -> type_extension; @@ -122,8 +125,8 @@ val tool_name: unit -> string ["ocaml"], ... Some global variables that reflect command-line options are automatically synchronized between the calling tool and the ppx preprocessor: {!Clflags.include_dirs}, - {!Load_path}, {!Clflags.open_modules}, {!Clflags.for_package}, - {!Clflags.debug}. *) + {!Clflags.hidden_include_dirs}, {!Load_path}, {!Clflags.open_modules}, + {!Clflags.for_package}, {!Clflags.debug}. *) val apply: source:string -> target:string -> mapper -> unit diff --git a/src/ocaml/parsing/attr_helper.ml b/src/ocaml/parsing/attr_helper.ml index 0a616cd746..390124199b 100644 --- a/src/ocaml/parsing/attr_helper.ml +++ b/src/ocaml/parsing/attr_helper.ml @@ -16,14 +16,17 @@ open Asttypes open Parsetree +module Style = Misc.Style + type error = | Multiple_attributes of string | No_payload_expected of string exception Error of Location.t * error -let get_no_payload_attribute alt_names attrs = - match List.filter (fun a -> List.mem a.attr_name.txt alt_names) attrs with +let get_no_payload_attribute nm attrs = + let actions = [(nm, Builtin_attributes.Return)] in + match Builtin_attributes.select_attributes actions attrs with | [] -> None | [ {attr_name = name; attr_payload = PStr []; attr_loc = _} ] -> Some name | [ {attr_name = name; _} ] -> @@ -40,9 +43,9 @@ open Format let report_error ppf = function | Multiple_attributes name -> - fprintf ppf "Too many `%s' attributes" name + fprintf ppf "Too many %a attributes" Style.inline_code name | No_payload_expected name -> - fprintf ppf "Attribute `%s' does not accept a payload" name + fprintf ppf "Attribute %a does not accept a payload" Style.inline_code name let () = Location.register_error_of_exn diff --git a/src/ocaml/parsing/attr_helper.mli b/src/ocaml/parsing/attr_helper.mli index a3ddc0c9cb..a94042a290 100644 --- a/src/ocaml/parsing/attr_helper.mli +++ b/src/ocaml/parsing/attr_helper.mli @@ -27,14 +27,11 @@ type error = | Multiple_attributes of string | No_payload_expected of string -(** The [string list] argument of the following functions is a list of - alternative names for the attribute we are looking for. For instance: - - {[ - ["foo"; "ocaml.foo"] - ]} *) -val get_no_payload_attribute : string list -> attributes -> string loc option -val has_no_payload_attribute : string list -> attributes -> bool +(** The [string] argument of the following functions is the name of the + attribute we are looking for. If the argument is ["foo"], these functions + will find attributes with the name ["foo"] or ["ocaml.foo"] *) +val get_no_payload_attribute : string -> attributes -> string loc option +val has_no_payload_attribute : string -> attributes -> bool exception Error of Location.t * error diff --git a/src/ocaml/parsing/builtin_attributes.ml b/src/ocaml/parsing/builtin_attributes.ml index 0db2133143..6add5ac375 100644 --- a/src/ocaml/parsing/builtin_attributes.ml +++ b/src/ocaml/parsing/builtin_attributes.ml @@ -15,6 +15,84 @@ open Asttypes open Parsetree +open Ast_helper + + +module Attribute_table = Hashtbl.Make (struct + type t = string with_loc + + let hash : t -> int = Hashtbl.hash + let equal : t -> t -> bool = (=) +end) +let unused_attrs = Attribute_table.create 128 +let mark_used t = Attribute_table.remove unused_attrs t + +(* [attr_order] is used to issue unused attribute warnings in the order the + attributes occur in the file rather than the random order of the hash table +*) +let attr_order a1 a2 = + match String.compare a1.loc.loc_start.pos_fname a2.loc.loc_start.pos_fname + with + | 0 -> Int.compare a1.loc.loc_start.pos_cnum a2.loc.loc_start.pos_cnum + | n -> n + +let warn_unused () = + let keys = List.of_seq (Attribute_table.to_seq_keys unused_attrs) in + let keys = List.sort attr_order keys in + List.iter (fun sloc -> + Location.prerr_warning sloc.loc (Warnings.Misplaced_attribute sloc.txt)) + keys + +(* These are the attributes that are tracked in the builtin_attrs table for + misplaced attribute warnings. *) +let builtin_attrs = + [ "alert" + ; "boxed" + ; "deprecated" + ; "deprecated_mutable" + ; "explicit_arity" + ; "immediate" + ; "immediate64" + ; "inline" + ; "inlined" + ; "noalloc" + ; "poll" + ; "ppwarning" + ; "specialise" + ; "specialised" + ; "tailcall" + ; "tail_mod_cons" + ; "unboxed" + ; "untagged" + ; "unrolled" + ; "warnerror" + ; "warning" + ; "warn_on_literal_pattern" + ] + +let builtin_attrs = + let tbl = Hashtbl.create 128 in + List.iter (fun attr -> Hashtbl.add tbl attr ()) builtin_attrs; + tbl + +let drop_ocaml_attr_prefix s = + let len = String.length s in + if String.starts_with ~prefix:"ocaml." s && len > 6 then + String.sub s 6 (len - 6) + else + s + +let is_builtin_attr s = Hashtbl.mem builtin_attrs (drop_ocaml_attr_prefix s) + +type current_phase = Parser | Invariant_check + +let register_attr current_phase name = + match current_phase with + | Parser when !Clflags.all_ppx <> [] -> () + | Parser | Invariant_check -> + if is_builtin_attr name.txt then + Attribute_table.replace unused_attrs name () + let string_of_cst = function | Pconst_string(s, _, _) -> Some s @@ -67,6 +145,41 @@ let error_of_extension ext = | ({txt; loc}, _) -> Location.errorf ~loc "Uninterpreted extension '%s'." txt +let attr_equals_builtin {attr_name = {txt; _}; _} s = + (* Check for attribute s or ocaml.s. Avoid allocating a fresh string. *) + txt = s || + ( String.length txt = 6 + String.length s + && String.starts_with ~prefix:"ocaml." txt + && String.ends_with ~suffix:s txt) + +let mark_alert_used a = + if attr_equals_builtin a "deprecated" || attr_equals_builtin a "alert" + then mark_used a.attr_name + +let mark_alerts_used l = List.iter mark_alert_used l + +let mark_warn_on_literal_pattern_used l = + List.iter (fun a -> + if attr_equals_builtin a "warn_on_literal_pattern" + then mark_used a.attr_name) + l + +let mark_deprecated_mutable_used l = + List.iter (fun a -> + if attr_equals_builtin a "deprecated_mutable" + then mark_used a.attr_name) + l + +let mark_payload_attrs_used payload = + let iter = + { Ast_iterator.default_iterator + with attribute = fun self a -> + mark_used a.attr_name; + Ast_iterator.default_iterator.attribute self a + } + in + iter.payload iter payload + let kind_and_message = function | PStr[ {pstr_desc= @@ -87,15 +200,14 @@ let cat s1 s2 = if s2 = "" then s1 else s1 ^ "\n" ^ s2 let alert_attr x = - match x.attr_name.txt with - | "ocaml.deprecated"|"deprecated" -> - Some (x, "deprecated", string_of_opt_payload x.attr_payload) - | "ocaml.alert"|"alert" -> - begin match kind_and_message x.attr_payload with - | Some (kind, message) -> Some (x, kind, message) - | None -> None (* note: bad payloads detected by warning_attribute *) - end - | _ -> None + if attr_equals_builtin x "deprecated" then + Some (x, "deprecated", string_of_opt_payload x.attr_payload) + else if attr_equals_builtin x "alert" then + begin match kind_and_message x.attr_payload with + | Some (kind, message) -> Some (x, kind, message) + | None -> None (* note: bad payloads detected by warning_attribute *) + end + else None let alert_attrs l = List.filter_map alert_attr l @@ -128,9 +240,8 @@ let check_alerts_inclusion ~def ~use loc attrs1 attrs2 s = let rec deprecated_mutable_of_attrs = function | [] -> None - | {attr_name = {txt = "ocaml.deprecated_mutable"|"deprecated_mutable"; _}; - attr_payload = p} :: _ -> - Some (string_of_opt_payload p) + | attr :: _ when attr_equals_builtin attr "deprecated_mutable" -> + Some (string_of_opt_payload attr.attr_payload) | _ :: tl -> deprecated_mutable_of_attrs tl let check_deprecated_mutable loc attrs s = @@ -164,73 +275,67 @@ let rec attrs_of_str = function let alerts_of_str str = alerts_of_attrs (attrs_of_str str) -let check_no_alert attrs = - List.iter - (fun (a, _, _) -> - Location.prerr_warning a.attr_loc - (Warnings.Misplaced_attribute a.attr_name.txt) - ) - (alert_attrs attrs) - let warn_payload loc txt msg = Location.prerr_warning loc (Warnings.Attribute_payload (txt, msg)) let warning_attribute ?(ppwarning = true) = - let process loc txt errflag payload = + let process loc name errflag payload = + mark_used name; match string_of_payload payload with | Some s -> begin try Option.iter (Location.prerr_alert loc) (Warnings.parse_options errflag s) - with Arg.Bad msg -> warn_payload loc txt msg + with Arg.Bad msg -> warn_payload loc name.txt msg end | None -> - warn_payload loc txt "A single string literal is expected" + warn_payload loc name.txt "A single string literal is expected" in - let process_alert loc txt = function + let process_alert loc name = function | PStr[{pstr_desc= Pstr_eval( {pexp_desc=Pexp_constant(Pconst_string(s,_,_))}, _) }] -> - begin try Warnings.parse_alert_option s - with Arg.Bad msg -> warn_payload loc txt msg + begin + mark_used name; + try Warnings.parse_alert_option s + with Arg.Bad msg -> warn_payload loc name.txt msg end | k -> + (* Don't [mark_used] in the [Some] cases - that happens in [Env] or + [type_mod] if they are in a valid place. Do [mark_used] in the + [None] case, which is just malformed and covered by the "Invalid + payload" warning. *) match kind_and_message k with | Some ("all", _) -> - warn_payload loc txt "The alert name 'all' is reserved" + warn_payload loc name.txt "The alert name 'all' is reserved" | Some _ -> () - | None -> warn_payload loc txt "Invalid payload" + | None -> begin + mark_used name; + warn_payload loc name.txt "Invalid payload" + end in - function - | {attr_name = {txt = ("ocaml.warning"|"warning") as txt; _}; - attr_loc; - attr_payload; - } -> - process attr_loc txt false attr_payload - | {attr_name = {txt = ("ocaml.warnerror"|"warnerror") as txt; _}; - attr_loc; - attr_payload - } -> - process attr_loc txt true attr_payload - | {attr_name = {txt="ocaml.ppwarning"|"ppwarning"; _}; - attr_loc = _; - attr_payload = - PStr [ - { pstr_desc= - Pstr_eval({pexp_desc=Pexp_constant (Pconst_string (s, _, _))},_); - pstr_loc } - ]; - } when ppwarning -> - Location.prerr_warning pstr_loc (Warnings.Preprocessor s) - | {attr_name = {txt = ("ocaml.alert"|"alert") as txt; _}; - attr_loc; - attr_payload; - } -> - process_alert attr_loc txt attr_payload - | _ -> - () + fun ({attr_name; attr_loc; attr_payload} as attr) -> + if attr_equals_builtin attr "warning" then + process attr_loc attr_name false attr_payload + else if attr_equals_builtin attr "warnerror" then + process attr_loc attr_name true attr_payload + else if attr_equals_builtin attr "alert" then + process_alert attr_loc attr_name attr_payload + else if ppwarning && attr_equals_builtin attr "ppwarning" then + begin match attr_payload with + | PStr [{ pstr_desc= + Pstr_eval({pexp_desc=Pexp_constant + (Pconst_string (s, _, _))},_); + pstr_loc }] -> + (mark_used attr_name; + Location.prerr_warning pstr_loc (Warnings.Preprocessor s)) + | _ -> + (mark_used attr_name; + warn_payload attr_loc attr_name.txt + "A single string literal is expected") + end let warning_scope ?ppwarning attrs f = let prev = Warnings.backup () in @@ -244,33 +349,34 @@ let warning_scope ?ppwarning attrs f = raise exn -let warn_on_literal_pattern = +let has_attribute nm attrs = List.exists - (fun a -> match a.attr_name.txt with - | "ocaml.warn_on_literal_pattern"|"warn_on_literal_pattern" -> true - | _ -> false - ) + (fun a -> + if attr_equals_builtin a nm + then (mark_used a.attr_name; true) + else false) + attrs -let explicit_arity = - List.exists - (fun a -> match a.attr_name.txt with - | "ocaml.explicit_arity"|"explicit_arity" -> true - | _ -> false - ) +type attr_action = Mark_used_only | Return +let select_attributes actions attrs = + List.filter (fun a -> + List.exists (fun (nm, action) -> + attr_equals_builtin a nm && + begin + mark_used a.attr_name; + action = Return + end) + actions + ) attrs -let immediate = - List.exists - (fun a -> match a.attr_name.txt with - | "ocaml.immediate"|"immediate" -> true - | _ -> false - ) +let warn_on_literal_pattern attrs = + has_attribute "warn_on_literal_pattern" attrs -let immediate64 = - List.exists - (fun a -> match a.attr_name.txt with - | "ocaml.immediate64"|"immediate64" -> true - | _ -> false - ) +let explicit_arity attrs = has_attribute "explicit_arity" attrs + +let immediate attrs = has_attribute "immediate" attrs + +let immediate64 attrs = has_attribute "immediate64" attrs (* The "ocaml.boxed (default)" and "ocaml.unboxed (default)" attributes cannot be input by the user, they are added by the @@ -279,11 +385,6 @@ let immediate64 = source file because the default can change between compiler invocations. *) -let check l a = List.mem a.attr_name.txt l - -let has_unboxed attr = - List.exists (check ["ocaml.unboxed"; "unboxed"]) - attr +let has_unboxed attrs = has_attribute "unboxed" attrs -let has_boxed attr = - List.exists (check ["ocaml.boxed"; "boxed"]) attr +let has_boxed attrs = has_attribute "boxed" attrs diff --git a/src/ocaml/parsing/builtin_attributes.mli b/src/ocaml/parsing/builtin_attributes.mli index 6200fd74ec..4eb5ef91f2 100644 --- a/src/ocaml/parsing/builtin_attributes.mli +++ b/src/ocaml/parsing/builtin_attributes.mli @@ -13,26 +13,103 @@ (* *) (**************************************************************************) -(** Support for some of the builtin attributes +(** Support for the builtin attributes: - - ocaml.deprecated - ocaml.alert - - ocaml.error - - ocaml.ppwarning - - ocaml.warning - - ocaml.warnerror - - ocaml.explicit_arity (for camlp4/camlp5) - - ocaml.warn_on_literal_pattern + - ocaml.boxed + - ocaml.deprecated - ocaml.deprecated_mutable + - ocaml.explicit_arity - ocaml.immediate - ocaml.immediate64 - - ocaml.boxed / ocaml.unboxed + - ocaml.inline + - ocaml.inlined + - ocaml.noalloc + - ocaml.poll + - ocaml.ppwarning + - ocaml.specialise + - ocaml.specialised + - ocaml.tailcall + - ocaml.tail_mod_cons + - ocaml.unboxed + - ocaml.untagged + - ocaml.unrolled + - ocaml.warnerror + - ocaml.warning + - ocaml.warn_on_literal_pattern {b Warning:} this module is unstable and part of {{!Compiler_libs}compiler-libs}. *) +(** {2 Attribute tracking for warning 53} *) + +(** [register_attr] must be called on the locations of all attributes that + should be tracked for the purpose of misplaced attribute warnings. In + particular, it should be called on all attributes that are present in the + source program except those that are contained in the payload of another + attribute (because these may be left behind by a ppx and intentionally + ignored by the compiler). + + The [current_phase] argument indicates when this function is being called + - either when an attribute is created in the parser or when we see an + attribute while running the check in the [Ast_invariants] module. This is + used to ensure that we track only attributes from the final version of the + parse tree: we skip adding attributes seen at parse time if we can see that + a ppx will be run later, because the [Ast_invariants] check is always run on + the result of a ppx. + + Note that the [Ast_invariants] check is also run on parse trees created from + marshalled ast files if no ppx is being used, ensuring we don't miss + attributes in that case. +*) +type current_phase = Parser | Invariant_check +val register_attr : current_phase -> string Location.loc -> unit + +(** Marks the attributes hiding in the payload of another attribute used, for + the purposes of misplaced attribute warnings (see comment on + [current_phase] above). In the parser, it's simplest to add these to + the table and remove them later, rather than threading through state + tracking whether we're in an attribute payload. *) +val mark_payload_attrs_used : Parsetree.payload -> unit + +(** Issue misplaced attribute warnings for all attributes created with + [mk_internal] but not yet marked used. *) +val warn_unused : unit -> unit + +(** {3 Warning 53 helpers for environment attributes} + + Some attributes, like deprecation markers, do not affect the compilation of + the definition on which they appear, but rather result in warnings on future + uses of that definition. This is implemented by moving the raw attributes + into the environment, where they will be noticed on future accesses. + + To make misplaced attribute warnings work appropriately for these + attributes, we mark them "used" when they are moved into the environment. + This is done with the helper functions in this section. +*) + +(** Marks the attribute used for the purposes of misplaced attribute warnings if + it is an alert. Call this when moving things allowed to have alert + attributes into the environment. *) +val mark_alert_used : Parsetree.attribute -> unit + +(** The same as [List.iter mark_alert_used]. *) +val mark_alerts_used : Parsetree.attributes -> unit + +(** Marks "warn_on_literal_pattern" attributes used for the purposes of + misplaced attribute warnings. Call this when moving constructors into the + environment. *) +val mark_warn_on_literal_pattern_used : Parsetree.attributes -> unit + +(** Marks "deprecated_mutable" attributes used for the purposes of misplaced + attribute warnings. Call this when moving labels of mutable fields into the + environment. *) +val mark_deprecated_mutable_used : Parsetree.attributes -> unit + +(** {2 Helpers for alert and warning attributes} *) + val check_alerts: Location.t -> Parsetree.attributes -> string -> unit val check_alerts_inclusion: def:Location.t -> use:Location.t -> Location.t -> Parsetree.attributes -> @@ -47,14 +124,12 @@ val check_deprecated_mutable_inclusion: def:Location.t -> use:Location.t -> Location.t -> Parsetree.attributes -> Parsetree.attributes -> string -> unit -val check_no_alert: Parsetree.attributes -> unit - val error_of_extension: Parsetree.extension -> Location.error val warning_attribute: ?ppwarning:bool -> Parsetree.attribute -> unit (** Apply warning settings from the specified attribute. - "ocaml.warning"/"ocaml.warnerror" (and variants without the prefix) - are processed and other attributes are ignored. + "ocaml.warning"/"ocaml.warnerror" (and variants without the prefix) are + processed and marked used for warning 53. Other attributes are ignored. Also implement ocaml.ppwarning (unless ~ppwarning:false is passed). @@ -73,10 +148,37 @@ val warning_scope: is executed. *) +(** {2 Helpers for searching for particular attributes} *) + +(** [has_attribute name attrs] is true if an attribute with name [name] or + ["ocaml." ^ name] is present in [attrs]. It marks that attribute used for + the purposes of misplaced attribute warnings. *) +val has_attribute : string -> Parsetree.attributes -> bool + +(** [select_attributes actions attrs] finds the elements of [attrs] that appear + in [actions] and either returns them or just marks them used, according to + the corresponding [attr_action]. + + Each element [(nm, action)] of the [actions] list is an attribute along with + an [attr_action] specifying what to do with that attribute. The action is + used to accommodate different compiler configurations. If an attribute is + used only in some compiler configurations, it's important that we still look + for it and mark it used when compiling with other configurations. + Otherwise, we would issue spurious misplaced attribute warnings. *) +type attr_action = Mark_used_only | Return +val select_attributes : + (string * attr_action) list -> Parsetree.attributes -> Parsetree.attributes + +(** [attr_equals_builtin attr s] is true if the name of the attribute is [s] or + ["ocaml." ^ s]. This is useful for manually inspecting attribute names, but + note that doing so will not result in marking the attribute used for the + purpose of warning 53, so it is usually preferrable to use [has_attribute] + or [select_attributes]. *) +val attr_equals_builtin : Parsetree.attribute -> string -> bool + val warn_on_literal_pattern: Parsetree.attributes -> bool val explicit_arity: Parsetree.attributes -> bool - val immediate: Parsetree.attributes -> bool val immediate64: Parsetree.attributes -> bool diff --git a/src/ocaml/parsing/lexer.ml b/src/ocaml/parsing/lexer.ml new file mode 100644 index 0000000000..3ebda68eb7 --- /dev/null +++ b/src/ocaml/parsing/lexer.ml @@ -0,0 +1,3 @@ +(* This forward reference is filled in Lexer_raw.mll *) +let is_keyword_ref : (string -> bool) ref = ref (fun _ -> false) +let is_keyword txt = !is_keyword_ref txt diff --git a/src/ocaml/parsing/location.ml b/src/ocaml/parsing/location.ml index bfb71c08a0..781a2e846b 100644 --- a/src/ocaml/parsing/location.ml +++ b/src/ocaml/parsing/location.ml @@ -16,21 +16,18 @@ open Lexing type t = Warnings.loc = - { loc_start: position; loc_end: position; loc_ghost: bool };; + { loc_start: position; loc_end: position; loc_ghost: bool } -let in_file name = - let loc = { dummy_pos with pos_fname = name } in - { loc_start = loc; loc_end = loc; loc_ghost = true } -;; +let in_file = Warnings.ghost_loc_in_file -let none = in_file "_none_";; -let is_none l = (l = none);; +let none = in_file "_none_" +let is_none l = (l = none) let curr lexbuf = { loc_start = lexbuf.lex_start_p; loc_end = lexbuf.lex_curr_p; loc_ghost = false -};; +} let init lexbuf fname = lexbuf.lex_curr_p <- { @@ -39,36 +36,36 @@ let init lexbuf fname = pos_bol = 0; pos_cnum = 0; } -;; + let symbol_rloc () = { loc_start = Parsing.symbol_start_pos (); loc_end = Parsing.symbol_end_pos (); loc_ghost = false; -};; +} let symbol_gloc () = { loc_start = Parsing.symbol_start_pos (); loc_end = Parsing.symbol_end_pos (); loc_ghost = true; -};; +} let rhs_loc n = { loc_start = Parsing.rhs_start_pos n; loc_end = Parsing.rhs_end_pos n; loc_ghost = false; -};; +} let rhs_interval m n = { loc_start = Parsing.rhs_start_pos m; loc_end = Parsing.rhs_end_pos n; loc_ghost = false; -};; +} (* return file, line, char from the given position *) let get_pos_info pos = (pos.pos_fname, pos.pos_lnum, pos.pos_cnum - pos.pos_bol) -;; + type 'a loc = { txt : 'a; @@ -83,19 +80,39 @@ let mknoloc txt = mkloc txt none let input_name = ref "_none_" let input_lexbuf = ref (None : lexbuf option) +let input_phrase_buffer = ref (None : Buffer.t option) (******************************************************************************) (* Terminal info *) +(* +let status = ref Terminfo.Uninitialised + +let setup_terminal () = + if !status = Terminfo.Uninitialised then + status := Terminfo.setup stdout +*) + (* The number of lines already printed after input. This is used by [highlight_terminfo] to identify the current position of the input in the terminal. This would not be possible without this information, since printing several warnings/errors adds text between the user input and the bottom of the terminal. + + We also use for {!is_first_report}, see below. *) let num_loc_lines = ref 0 +(* We use [num_loc_lines] to determine if the report about to be + printed is the first or a follow-up report of the current + "batch" -- contiguous reports without user input in between, for + example for the current toplevel phrase. We use this to print + a blank line between messages of the same batch. +*) +let is_first_message () = + !num_loc_lines = 0 + (* This is used by the toplevel to reset [num_loc_lines] before each phrase *) let reset () = num_loc_lines := 0 @@ -105,6 +122,13 @@ let echo_eof () = print_newline (); incr num_loc_lines +(* This is used by the toplevel and the report printers below. *) +let separate_new_message ppf = + if not (is_first_message ()) then begin + Format.pp_print_newline ppf (); + incr num_loc_lines + end + (* Code printing errors and warnings must be wrapped using this function, in order to update [num_loc_lines]. @@ -126,6 +150,11 @@ let print_updating_num_loc_lines ppf f arg = pp_print_flush ppf (); pp_set_formatter_out_functions ppf out_functions +(* +let setup_tags () = + Misc.Style.setup !Clflags.color +*) + (******************************************************************************) (* Printing locations, e.g. 'File "foo.ml", line 3, characters 10-12' *) @@ -137,12 +166,40 @@ let rewrite_absolute_path path = *) path +(* +let rewrite_find_first_existing path = + match Misc.get_build_path_prefix_map () with + | None -> + if Sys.file_exists path then Some path + else None + | Some prefix_map -> + match Build_path_prefix_map.rewrite_all prefix_map path with + | [] -> + if Sys.file_exists path then Some path + else None + | matches -> + Some (List.find Sys.file_exists matches) + +let rewrite_find_all_existing_dirs path = + let ok path = Sys.file_exists path && Sys.is_directory path in + match Misc.get_build_path_prefix_map () with + | None -> + if ok path then [path] + else [] + | Some prefix_map -> + match Build_path_prefix_map.rewrite_all prefix_map path with + | [] -> + if ok path then [path] + else [] + | matches -> + match (List.filter ok matches) with + | [] -> raise Not_found + | results -> results *) + let absolute_path s = (* This function could go into Filename *) let open Filename in - let s = - if not (is_relative s) then s - else (rewrite_absolute_path (concat (Sys.getcwd ()) s)) - in + let s = if (is_relative s) then (concat (Sys.getcwd ()) s) else s in + let s = rewrite_absolute_path s in (* Now simplify . and .. components *) let rec aux s = let base = basename s in @@ -167,6 +224,7 @@ let print_filename ppf file = location might be invalid; in which case we do not print it. *) let print_loc ppf loc = + (* setup_tags (); *) let file_valid = function | "_none_" -> (* This is a dummy placeholder, but we print it anyway to please editors @@ -380,6 +438,79 @@ let infer_line_numbers See [lines_around_from_current_input] below for an instantiation of [get_lines] that reads from the current input. *) +(* +let highlight_quote ppf + ~(get_lines: start_pos:position -> end_pos:position -> input_line list) + ?(max_lines = 10) + highlight_tag + locs + = + let iset = ISet.of_intervals @@ List.filter_map (fun loc -> + let s, e = loc.loc_start, loc.loc_end in + if s.pos_cnum = -1 || e.pos_cnum = -1 then None + else Some ((s, s.pos_cnum), (e, e.pos_cnum - 1)) + ) locs in + match ISet.extrema iset with + | None -> () + | Some ((leftmost, _), (rightmost, _)) -> + let lines = + get_lines ~start_pos:leftmost ~end_pos:rightmost + |> List.map (fun ({ text; start_pos } as line) -> + let end_pos = start_pos + String.length text - 1 in + let line_nb = + match ISet.find_bound_in iset ~range:(start_pos, end_pos) with + | None -> None + | Some (p, _) -> Some p.pos_lnum + in + (line_nb, line)) + |> infer_line_numbers + |> List.map (fun (lnum, { text; start_pos }) -> + (text, + Option.fold ~some:Int.to_string ~none:"" lnum, + start_pos)) + in + Format.fprintf ppf "@["; + begin match lines with + | [] | [("", _, _)] -> () + | [(line, line_nb, line_start_cnum)] -> + (* Single-line error *) + Format.fprintf ppf "%s | %s@," line_nb line; + Format.fprintf ppf "%*s " (String.length line_nb) ""; + (* Iterate up to [rightmost], which can be larger than the length of + the line because we may point to a location after the end of the + last token on the line, for instance: + {[ + token + ^ + Did you forget ... + ]} *) + for i = 0 to rightmost.pos_cnum - line_start_cnum - 1 do + let pos = line_start_cnum + i in + if ISet.is_start iset ~pos <> None then + Format.fprintf ppf "@{<%s>" highlight_tag; + if ISet.mem iset ~pos then Format.pp_print_char ppf '^' + else if i < String.length line then begin + (* For alignment purposes, align using a tab for each tab in the + source code *) + if line.[i] = '\t' then Format.pp_print_char ppf '\t' + else Format.pp_print_char ppf ' ' + end; + if ISet.is_end iset ~pos <> None then + Format.fprintf ppf "@}" + done; + Format.fprintf ppf "@}@," + | _ -> + (* Multi-line error *) + Misc.pp_two_columns ~sep:"|" ~max_lines ppf + @@ List.map (fun (line, line_nb, line_start_cnum) -> + let line = String.mapi (fun i car -> + if ISet.mem iset ~pos:(line_start_cnum + i) then car else '.' + ) line in + (line_nb, line) + ) lines + end; + Format.fprintf ppf "@]" +*) @@ -423,7 +554,7 @@ let lines_around *) (* -(* Try to get lines from a lexbuf *) +(* Attempt to get lines from the lexing buffer. *) let lines_around_from_lexbuf ~(start_pos: position) ~(end_pos: position) (lb: lexbuf): @@ -449,55 +580,35 @@ let lines_around_from_lexbuf *) (* -(* Get lines from a file *) -let lines_around_from_file +(* Attempt to get lines from the phrase buffer *) +let lines_around_from_phrasebuf ~(start_pos: position) ~(end_pos: position) - (filename: string): + (pb: Buffer.t): input_line list = - try - let cin = open_in_bin filename in - let read_char () = - try Some (input_char cin) with End_of_file -> None - in - let lines = - lines_around ~start_pos ~end_pos ~seek:(seek_in cin) ~read_char - in - close_in cin; - lines - with Sys_error _ -> [] + let pos = ref 0 in + let seek n = pos := n in + let read_char () = + if !pos >= Buffer.length pb then None + else begin + let c = Buffer.nth pb !pos in + incr pos; Some c + end + in + lines_around ~start_pos ~end_pos ~seek ~read_char *) (* (* A [get_lines] function for [highlight_quote] that reads from the current - input. - - It first tries to read from [!input_lexbuf], then if that fails (because the - lexbuf no longer contains the input we want), it reads from [!input_name] - directly *) + input. *) let lines_around_from_current_input ~start_pos ~end_pos = - (* Be a bit defensive, and do not try to open one of the possible - [!input_name] values that we know do not denote valid filenames. *) - let file_valid = function - | "//toplevel//" | "_none_" | "" -> false - | _ -> true - in - let from_file () = - if file_valid !input_name then - lines_around_from_file !input_name ~start_pos ~end_pos - else + match !input_lexbuf, !input_phrase_buffer, !input_name with + | _, Some pb, "//toplevel//" -> + lines_around_from_phrasebuf pb ~start_pos ~end_pos + | Some lb, _, _ -> + lines_around_from_lexbuf lb ~start_pos ~end_pos + | None, _, _ -> [] - in - match !input_lexbuf with - | Some lb -> - begin match lines_around_from_lexbuf lb ~start_pos ~end_pos with - | [] -> (* The input is likely not in the lexbuf anymore *) - from_file () - | lines -> - lines - end - | None -> - from_file () *) (******************************************************************************) @@ -616,6 +727,8 @@ let batch_mode_printer : report_printer = in let pp_txt ppf txt = Format.fprintf ppf "@[%t@]" txt in let pp self ppf report = + (* setup_tags (); *) + separate_new_message ppf; (* Make sure we keep [num_loc_lines] updated. The tabulation box is here to give submessage the option to be aligned with the main message box @@ -666,6 +779,34 @@ let batch_mode_printer : report_printer = { pp; pp_report_kind; pp_main_loc; pp_main_txt; pp_submsgs; pp_submsg; pp_submsg_loc; pp_submsg_txt } +(* +let terminfo_toplevel_printer (lb: lexbuf): report_printer = + let pp self ppf err = + setup_tags (); + (* Highlight all toplevel locations of the report, instead of displaying + the main location. Do it now instead of in [pp_main_loc], to avoid + messing with Format boxes. *) + let sub_locs = List.map (fun { loc; _ } -> loc) err.sub in + let all_locs = err.main.loc :: sub_locs in + let locs_highlighted = List.filter is_quotable_loc all_locs in + highlight_terminfo lb ppf locs_highlighted; + batch_mode_printer.pp self ppf err + in + let pp_main_loc _ _ _ _ = () in + let pp_submsg_loc _ _ ppf loc = + if not loc.loc_ghost then + Format.fprintf ppf "%a:@ " print_loc loc in + { batch_mode_printer with pp; pp_main_loc; pp_submsg_loc } + +let best_toplevel_printer () = + setup_terminal (); + match !status, !input_lexbuf with + | Terminfo.Good_term, Some lb -> + terminfo_toplevel_printer lb + | _, _ -> + batch_mode_printer +*) + (* Creates a printer for the current input *) let default_report_printer () : report_printer = batch_mode_printer @@ -735,7 +876,7 @@ let print_warning loc ppf w = | Some report -> print_report ppf report let prerr_warning_ref = - ref (fun loc w -> print_warning loc !formatter_for_warnings w);; + ref (fun loc w -> print_warning loc !formatter_for_warnings w) let prerr_warning loc w = !prerr_warning_ref loc w let default_alert_reporter = @@ -765,6 +906,44 @@ let alert ?(def = none) ?(use = none) ~kind loc message = let deprecated ?def ?use loc message = alert ?def ?use ~kind:"deprecated" loc message + +module Style = Misc.Style + +let auto_include_alert lib = + let message = Format.asprintf "\ + OCaml's lib directory layout changed in 5.0. The %a subdirectory has been \ + automatically added to the search path, but you should add %a to the \ + command-line to silence this alert (e.g. by adding %a to the list of \ + libraries in your dune file, or adding %a to your %a file for \ + ocamlbuild, or using %a for ocamlfind)." + Style.inline_code lib + Style.inline_code ("-I +" ^lib) + Style.inline_code lib + Style.inline_code ("use_"^lib) + Style.inline_code "_tags" + Style.inline_code ("-package " ^ lib) in + let alert = + {Warnings.kind="ocaml_deprecated_auto_include"; use=none; def=none; + message = Format.asprintf "@[@\n%a@]" Format.pp_print_text message} + in + prerr_alert none alert + +let deprecated_script_alert program = + let message = Format.asprintf "\ + Running %a where the first argument is an implicit basename with no \ + extension (e.g. %a) is deprecated. Either rename the script \ + (%a) or qualify the basename (%a)" + Style.inline_code program + Style.inline_code (program ^ " script-file") + Style.inline_code (program ^ " script-file.ml") + Style.inline_code (program ^ " ./script-file") + in + let alert = + {Warnings.kind="ocaml_deprecated_cli"; use=none; def=none; + message = Format.asprintf "@[@\n%a@]" Format.pp_print_text message} + in + prerr_alert none alert + (******************************************************************************) (* Reporting errors on exceptions *) diff --git a/src/ocaml/parsing/location.mli b/src/ocaml/parsing/location.mli index 63038ca62c..6681309d53 100644 --- a/src/ocaml/parsing/location.mli +++ b/src/ocaml/parsing/location.mli @@ -39,6 +39,7 @@ val none : t (** An arbitrary value of type [t]; describes an empty ghost range. *) val is_none : t -> bool +(** True for [Location.none], false any other location *) val in_file : string -> t (** Return an empty ghost range located in a given file. *) @@ -76,21 +77,96 @@ val mkloc : 'a -> t -> 'a loc val input_name: string ref val input_lexbuf: Lexing.lexbuf option ref +(* This is used for reporting errors coming from the toplevel. + + When running a toplevel session (i.e. when [!input_name] is "//toplevel//"), + [!input_phrase_buffer] should be [Some buf] where [buf] contains the last + toplevel phrase. *) +val input_phrase_buffer: Buffer.t option ref (** {1 Toplevel-specific functions} *) val echo_eof: unit -> unit +val separate_new_message: formatter -> unit val reset: unit -> unit -(** {1 Printing locations} *) +(** {1 Rewriting path } *) val rewrite_absolute_path: string -> string - (** rewrite absolute path to honor the BUILD_PATH_PREFIX_MAP - variable (https://reproducible-builds.org/specs/build-path-prefix-map/) - if it is set. *) +(** [rewrite_absolute_path path] rewrites [path] to honor the + BUILD_PATH_PREFIX_MAP variable + if it is set. It does not check whether [path] is absolute or not. + The result is as follows: + - If BUILD_PATH_PREFIX_MAP is not set, just return [path]. + - otherwise, rewrite using the mapping (and if there are no + matching prefixes that will just return [path]). + + See + {{: https://reproducible-builds.org/specs/build-path-prefix-map/ } + the BUILD_PATH_PREFIX_MAP spec} + *) + +(* +val rewrite_find_first_existing: string -> string option +*) +(** [rewrite_find_first_existing path] uses a BUILD_PATH_PREFIX_MAP mapping + and tries to find a source in mapping + that maps to a result that exists in the file system. + There are the following return values: + - [None], means either + {ul {- BUILD_PATH_PREFIX_MAP is not set and [path] does not exists, or} + {- no source prefixes of [path] in the mapping were found,}} + - [Some target], means [target] exists and either + {ul {- BUILD_PATH_PREFIX_MAP is not set and [target] = [path], or} + {- [target] is the first file (in priority + order) that [path] mapped to that exists in the file system.}} + - [Not_found] raised, means some source prefixes in the map + were found that matched [path], but none of them existed + in the file system. The caller should catch this and issue + an appropriate error message. + + See + {{: https://reproducible-builds.org/specs/build-path-prefix-map/ } + the BUILD_PATH_PREFIX_MAP spec} + *) + +(* +val rewrite_find_all_existing_dirs: string -> string list +*) +(** [rewrite_find_all_existing_dirs dir] accumulates a list of existing + directories, [dirs], that are the result of mapping a potentially + abstract directory, [dir], over all the mapping pairs in the + BUILD_PATH_PREFIX_MAP environment variable, if any. The list [dirs] + will be in priority order (head as highest priority). + + The possible results are: + - [[]], means either + {ul {- BUILD_PATH_PREFIX_MAP is not set and [dir] is not an existing + directory, or} + {- if set, then there were no matching prefixes of [dir].}} + - [Some dirs], means dirs are the directories found. Either + {ul {- BUILD_PATH_PREFIX_MAP is not set and [dirs = [dir]], or} + {- it was set and [dirs] are the mapped existing directories.}} + - Not_found raised, means some source prefixes in the map + were found that matched [dir], but none of mapping results + were existing directories (possibly due to misconfiguration). + The caller should catch this and issue an appropriate error + message. + + See + {{: https://reproducible-builds.org/specs/build-path-prefix-map/ } + the BUILD_PATH_PREFIX_MAP spec} + *) val absolute_path: string -> string + (** [absolute_path path] first makes an absolute path, [s] from [path], + prepending the current working directory if [path] was relative. + Then [s] is rewritten using [rewrite_absolute_path]. + Finally the result is normalized by eliminating instances of + ['.'] or ['..']. *) + +(** {1 Printing locations} *) val show_filename: string -> string (** In -absname mode, return the absolute path for this filename. @@ -101,7 +177,11 @@ val print_filename: formatter -> string -> unit val print_loc: formatter -> t -> unit val print_locs: formatter -> t list -> unit - +(** {1 Toplevel-specific location highlighting} *) +(* +val highlight_terminfo: + Lexing.lexbuf -> formatter -> t list -> unit +*) (** {1 Reporting errors and warnings} *) @@ -127,6 +207,7 @@ type report = { source : error_source; } +(* Exposed for Merlin *) val loc_of_report: report -> t val print_main : formatter -> report -> unit val print_sub_msg : formatter -> msg -> unit @@ -159,6 +240,12 @@ type report_printer = { (** {2 Report printers used in the compiler} *) val batch_mode_printer: report_printer +(* +val terminfo_toplevel_printer: Lexing.lexbuf -> report_printer + +val best_toplevel_printer: unit -> report_printer +(** Detects the terminal capabilities and selects an adequate printer *) +*) (** {2 Printing a [report]} *) @@ -236,6 +323,13 @@ val deprecated: ?def:t -> ?use:t -> t -> string -> unit val alert: ?def:t -> ?use:t -> kind:string -> t -> string -> unit (** Prints an arbitrary alert. *) +val auto_include_alert: string -> unit +(** Prints an alert that -I +lib has been automatically added to the load + path *) + +val deprecated_script_alert: string -> unit +(** [deprecated_script_alert command] prints an alert that [command foo] has + been deprecated in favour of [command ./foo] *) (** {1 Reporting errors} *) diff --git a/src/ocaml/parsing/location_aux.ml b/src/ocaml/parsing/location_aux.ml index 966ebdd3f7..5a9ec92d87 100644 --- a/src/ocaml/parsing/location_aux.ml +++ b/src/ocaml/parsing/location_aux.ml @@ -46,6 +46,10 @@ let compare_pos pos loc = else 0 +let included ~into:parent_loc child_loc = +Lexing.compare_pos child_loc.loc_start parent_loc.loc_start >= 0 && + Lexing.compare_pos parent_loc.loc_end child_loc.loc_end >= 0 + let union l1 l2 = if l1 = Location.none then l2 else if l2 = Location.none then l1 diff --git a/src/ocaml/parsing/location_aux.mli b/src/ocaml/parsing/location_aux.mli index 7d99d36a05..d6164b2cd7 100644 --- a/src/ocaml/parsing/location_aux.mli +++ b/src/ocaml/parsing/location_aux.mli @@ -42,6 +42,10 @@ val union : t -> t -> t (** Like location_union, but keep loc_ghost'ness of first argument *) val extend : t -> t -> t +(** [included ~into:parent child] returns [true] if [child] is included + in [parent]. Otherwise returns [false]. *) +val included : into:t -> t -> bool + (** Filter valid errors, log invalid ones *) val prepare_errors : exn list -> Location.error list diff --git a/src/ocaml/parsing/parsetree.mli b/src/ocaml/parsing/parsetree.mli index d0e64bd4fd..2f0a40c26c 100644 --- a/src/ocaml/parsing/parsetree.mli +++ b/src/ocaml/parsing/parsetree.mli @@ -121,7 +121,7 @@ and core_type_desc = - [T #tconstr] when [l=[T]], - [(T1, ..., Tn) #tconstr] when [l=[T1 ; ... ; Tn]]. *) - | Ptyp_alias of core_type * string (** [T as 'a]. *) + | Ptyp_alias of core_type * string loc (** [T as 'a]. *) | Ptyp_variant of row_field list * closed_flag * label list option (** [Ptyp_variant([`A;`B], flag, labels)] represents: - [[ `A|`B ]] @@ -166,6 +166,7 @@ and core_type_desc = {!value_description}. *) | Ptyp_package of package_type (** [(module S)]. *) + | Ptyp_open of Longident.t loc * core_type (** [M.(T)] *) | Ptyp_extension of extension (** [[%id]]. *) and package_type = Longident.t loc * (Longident.t loc * core_type) list @@ -296,30 +297,21 @@ and expression_desc = - [let rec P1 = E1 and ... and Pn = EN in E] when [flag] is {{!Asttypes.rec_flag.Recursive}[Recursive]}. *) - | Pexp_function of case list (** [function P1 -> E1 | ... | Pn -> En] *) - | Pexp_fun of arg_label * expression option * pattern * expression - (** [Pexp_fun(lbl, exp0, P, E1)] represents: - - [fun P -> E1] - when [lbl] is {{!Asttypes.arg_label.Nolabel}[Nolabel]} - and [exp0] is [None] - - [fun ~l:P -> E1] - when [lbl] is {{!Asttypes.arg_label.Labelled}[Labelled l]} - and [exp0] is [None] - - [fun ?l:P -> E1] - when [lbl] is {{!Asttypes.arg_label.Optional}[Optional l]} - and [exp0] is [None] - - [fun ?l:(P = E0) -> E1] - when [lbl] is {{!Asttypes.arg_label.Optional}[Optional l]} - and [exp0] is [Some E0] - - Notes: - - If [E0] is provided, only - {{!Asttypes.arg_label.Optional}[Optional]} is allowed. - - [fun P1 P2 .. Pn -> E1] is represented as nested - {{!expression_desc.Pexp_fun}[Pexp_fun]}. - - [let f P = E] is represented using - {{!expression_desc.Pexp_fun}[Pexp_fun]}. - *) + | Pexp_function of + function_param list * type_constraint option * function_body + (** [Pexp_function ([P1; ...; Pn], C, body)] represents any construct + involving [fun] or [function], including: + - [fun P1 ... Pn -> E] + when [body = Pfunction_body E] + - [fun P1 ... Pn -> function p1 -> e1 | ... | pm -> em] + when [body = Pfunction_cases [ p1 -> e1; ...; pm -> em ]] + + [C] represents a type constraint or coercion placed immediately before the + arrow, e.g. [fun P1 ... Pn : ty -> ...] when [C = Some (Pconstraint ty)]. + + A function must have parameters. [Pexp_function (params, _, body)] must + have non-empty [params] or a [Pfunction_cases _] body. + *) | Pexp_apply of expression * (arg_label * expression) list (** [Pexp_apply(E0, [(l1, E1) ; ... ; (ln, En)])] represents [E0 ~l1:E1 ... ~ln:En] @@ -440,6 +432,66 @@ and binding_op = pbop_loc : Location.t; } +and function_param_desc = + | Pparam_val of arg_label * expression option * pattern + (** [Pparam_val (lbl, exp0, P)] represents the parameter: + - [P] + when [lbl] is {{!Asttypes.arg_label.Nolabel}[Nolabel]} + and [exp0] is [None] + - [~l:P] + when [lbl] is {{!Asttypes.arg_label.Labelled}[Labelled l]} + and [exp0] is [None] + - [?l:P] + when [lbl] is {{!Asttypes.arg_label.Optional}[Optional l]} + and [exp0] is [None] + - [?l:(P = E0)] + when [lbl] is {{!Asttypes.arg_label.Optional}[Optional l]} + and [exp0] is [Some E0] + + Note: If [E0] is provided, only + {{!Asttypes.arg_label.Optional}[Optional]} is allowed. + *) + | Pparam_newtype of string loc + (** [Pparam_newtype x] represents the parameter [(type x)]. + [x] carries the location of the identifier, whereas the [pparam_loc] + on the enclosing [function_param] node is the location of the [(type x)] + as a whole. + + Multiple parameters [(type a b c)] are represented as multiple + [Pparam_newtype] nodes, let's say: + + {[ [ { pparam_kind = Pparam_newtype a; pparam_loc = loc1 }; + { pparam_kind = Pparam_newtype b; pparam_loc = loc2 }; + { pparam_kind = Pparam_newtype c; pparam_loc = loc3 }; + ] + ]} + + Here, the first loc [loc1] is the location of [(type a b c)], and the + subsequent locs [loc2] and [loc3] are the same as [loc1], except marked as + ghost locations. The locations on [a], [b], [c], correspond to the + variables [a], [b], and [c] in the source code. + *) + +and function_param = + { pparam_loc : Location.t; + pparam_desc : function_param_desc; + } + +and function_body = + | Pfunction_body of expression + | Pfunction_cases of case list * Location.t * attributes + (** In [Pfunction_cases (_, loc, attrs)], the location extends from the + start of the [function] keyword to the end of the last case. The compiler + will only use typechecking-related attributes from [attrs], e.g. enabling + or disabling a warning. + *) +(** See the comment on {{!expression_desc.Pexp_function}[Pexp_function]}. *) + +and type_constraint = + | Pconstraint of core_type + | Pcoerce of core_type option * core_type +(** See the comment on {{!expression_desc.Pexp_function}[Pexp_function]}. *) + (** {2 Value descriptions} *) and value_description = @@ -960,7 +1012,8 @@ and module_expr_desc = | Pmod_structure of structure (** [struct ... end] *) | Pmod_functor of functor_parameter * module_expr (** [functor(X : MT1) -> ME] *) - | Pmod_apply of module_expr * module_expr (** [ME1(ME2)] *) + | Pmod_apply of module_expr * module_expr (** [ME1(ME2)] *) + | Pmod_apply_unit of module_expr (** [ME1()] *) | Pmod_constraint of module_expr * module_type (** [(ME : MT)] *) | Pmod_unpack of expression (** [(val E)] *) | Pmod_extension of extension (** [[%id]] *) @@ -1004,13 +1057,30 @@ and structure_item_desc = | Pstr_attribute of attribute (** [[\@\@\@id]] *) | Pstr_extension of extension * attributes (** [[%%id]] *) +and value_constraint = + | Pvc_constraint of { + locally_abstract_univars:string loc list; + typ:core_type; + } + | Pvc_coercion of {ground:core_type option; coercion:core_type } + (** + - [Pvc_constraint { locally_abstract_univars=[]; typ}] + is a simple type constraint on a value binding: [ let x : typ] + - More generally, in [Pvc_constraint { locally_abstract_univars; typ}] + [locally_abstract_univars] is the list of locally abstract type + variables in [ let x: type a ... . typ ] + - [Pvc_coercion { ground=None; coercion }] represents [let x :> typ] + - [Pvc_coercion { ground=Some g; coercion }] represents [let x : g :> typ] + *) + and value_binding = { pvb_pat: pattern; pvb_expr: expression; + pvb_constraint: value_constraint option; pvb_attributes: attributes; pvb_loc: Location.t; - } + }(** [let pat : type_constraint = exp] *) and module_binding = { diff --git a/src/ocaml/parsing/pprintast.ml b/src/ocaml/parsing/pprintast.ml index 5b2e8c425e..ef87dcb4af 100644 --- a/src/ocaml/parsing/pprintast.ml +++ b/src/ocaml/parsing/pprintast.ml @@ -26,9 +26,8 @@ open Format open Location open Longident open Parsetree -open Ast_helper -let prefix_symbols = [ '!'; '?'; '~' ] ;; +let prefix_symbols = [ '!'; '?'; '~' ] let infix_symbols = [ '='; '<'; '>'; '@'; '^'; '|'; '&'; '+'; '-'; '*'; '/'; '$'; '%'; '#' ] @@ -95,22 +94,26 @@ let needs_parens txt = let needs_spaces txt = first_is '*' txt || last_is '*' txt -let string_loc ppf x = fprintf ppf "%s" x.txt - -(* add parentheses to binders when they are in fact infix or prefix operators *) -let protect_ident ppf txt = +(* Turn an arbitrary variable name into a valid OCaml identifier by adding \# + in case it is a keyword, or parenthesis when it is an infix or prefix + operator. *) +let ident_of_name ppf txt = let format : (_, _, _) format = - if not (needs_parens txt) then "%s" + if Lexer.is_keyword txt then "\\#%s" + else if not (needs_parens txt) then "%s" else if needs_spaces txt then "(@;%s@;)" else "(%s)" in fprintf ppf format txt +let ident_of_name_loc ppf s = ident_of_name ppf s.txt + let protect_longident ppf print_longident longprefix txt = - let format : (_, _, _) format = - if not (needs_parens txt) then "%a.%s" - else if needs_spaces txt then "%a.(@;%s@;)" - else "%a.(%s)" in - fprintf ppf format print_longident longprefix txt + if not (needs_parens txt) then + fprintf ppf "%a.%a" print_longident longprefix ident_of_name txt + else if needs_spaces txt then + fprintf ppf "%a.(@;%s@;)" print_longident longprefix txt + else + fprintf ppf "%a.(%s)" print_longident longprefix txt type space_formatter = (unit, Format.formatter, unit) format @@ -134,11 +137,15 @@ type construct = | `nil | `normal | `simple of Longident.t - | `tuple ] + | `tuple + | `btrue + | `bfalse ] let view_expr x = match x.pexp_desc with | Pexp_construct ( {txt= Lident "()"; _},_) -> `tuple + | Pexp_construct ( {txt= Lident "true"; _},_) -> `btrue + | Pexp_construct ( {txt= Lident "false"; _},_) -> `bfalse | Pexp_construct ( {txt= Lident "[]";_},_) -> `nil | Pexp_construct ( {txt= Lident"::";_},Some _) -> let rec loop exp acc = match exp with @@ -161,7 +168,7 @@ let view_expr x = | _ -> `normal let is_simple_construct :construct -> bool = function - | `nil | `tuple | `list _ | `simple _ -> true + | `nil | `tuple | `list _ | `simple _ | `btrue | `bfalse -> true | `cons _ | `normal -> false let pp = fprintf @@ -170,12 +177,14 @@ type ctxt = { pipe : bool; semi : bool; ifthenelse : bool; + functionrhs : bool; } -let reset_ctxt = { pipe=false; semi=false; ifthenelse=false } +let reset_ctxt = { pipe=false; semi=false; ifthenelse=false; functionrhs=false } let under_pipe ctxt = { ctxt with pipe=true } let under_semi ctxt = { ctxt with semi=true } let under_ifthenelse ctxt = { ctxt with ifthenelse=true } +let under_functionrhs ctxt = { ctxt with functionrhs = true } (* let reset_semi ctxt = { ctxt with semi=false } let reset_ifthenelse ctxt = { ctxt with ifthenelse=false } @@ -217,7 +226,7 @@ let paren: 'a . ?first:space_formatter -> ?last:space_formatter -> else fu f x let rec longident f = function - | Lident s -> protect_ident f s + | Lident s -> ident_of_name f s | Ldot(y,s) -> protect_longident f longident y s | Lapply (y,s) -> pp f "%a(%a)" longident y longident s @@ -268,16 +277,23 @@ let iter_loc f ctxt {txt; loc = _} = f ctxt txt let constant_string f s = pp f "%S" s -let tyvar ppf s = +let tyvar_of_name s = if String.length s >= 2 && s.[1] = '\'' then (* without the space, this would be parsed as a character literal *) - Format.fprintf ppf "' %s" s + "' " ^ s + else if Lexer.is_keyword s then + "'\\#" ^ s + else if String.equal s "_" then + s else - Format.fprintf ppf "'%s" s + "'" ^ s + +let tyvar ppf s = + Format.fprintf ppf "%s" (tyvar_of_name s) let tyvar_loc f str = tyvar f str.txt -let string_quot f x = pp f "`%s" x +let string_quot f x = pp f "`%a" ident_of_name x (* c ['a,'b] *) let rec class_params_def ctxt f = function @@ -289,8 +305,8 @@ let rec class_params_def ctxt f = function and type_with_label ctxt f (label, c) = match label with | Nolabel -> core_type1 ctxt f c (* otherwise parenthesize *) - | Labelled s -> pp f "%s:%a" s (core_type1 ctxt) c - | Optional s -> pp f "?%s:%a" s (core_type1 ctxt) c + | Labelled s -> pp f "%a:%a" ident_of_name s (core_type1 ctxt) c + | Optional s -> pp f "?%a:%a" ident_of_name s (core_type1 ctxt) c and core_type ctxt f x = if x.ptyp_attributes <> [] then begin @@ -302,19 +318,16 @@ and core_type ctxt f x = pp f "@[<2>%a@;->@;%a@]" (* FIXME remove parens later *) (type_with_label ctxt) (l,ct1) (core_type ctxt) ct2 | Ptyp_alias (ct, s) -> - pp f "@[<2>%a@;as@;%a@]" (core_type1 ctxt) ct tyvar s + pp f "@[<2>%a@;as@;%a@]" (core_type1 ctxt) ct tyvar s.txt | Ptyp_poly ([], ct) -> core_type ctxt f ct | Ptyp_poly (sl, ct) -> pp f "@[<2>%a%a@]" - (fun f l -> - pp f "%a" (fun f l -> match l with | [] -> () | _ -> pp f "%a@;.@;" (list tyvar_loc ~sep:"@;") l) - l) sl (core_type ctxt) ct | _ -> pp f "@[<2>%a@]" (core_type1 ctxt) x @@ -366,7 +379,7 @@ and core_type1 ctxt f x = let core_field_type f x = match x.pof_desc with | Otag (l, ct) -> (* Cf #7200 *) - pp f "@[%s: %a@ %a@ @]" l.txt + pp f "@[%a: %a@ %a@ @]" ident_of_name l.txt (core_type ctxt) ct (attributes ctxt) x.pof_attributes | Oinherit ct -> pp f "@[%a@ @]" (core_type ctxt) ct @@ -393,8 +406,11 @@ and core_type1 ctxt f x = |_ -> pp f "@[(module@ %a@ with@ %a)@]" longident_loc lid (list aux ~sep:"@ and@ ") cstrs) + | Ptyp_open(li, ct) -> + pp f "@[%a.(%a)@]" longident_loc li (core_type ctxt) ct | Ptyp_extension e -> extension ctxt f e - | _ -> paren true (core_type ctxt) f x + | (Ptyp_arrow _ | Ptyp_alias _ | Ptyp_poly _) -> + paren true (core_type ctxt) f x (********************pattern********************) (* be cautious when use [pattern], [pattern1] is preferred *) @@ -405,7 +421,7 @@ and pattern ctxt f x = end else match x.ppat_desc with | Ppat_alias (p, s) -> - pp f "@[<2>%a@;as@;%a@]" (pattern ctxt) p protect_ident s.txt + pp f "@[<2>%a@;as@;%a@]" (pattern ctxt) p ident_of_name s.txt | _ -> pattern_or ctxt f x and pattern_or ctxt f x = @@ -435,8 +451,8 @@ and pattern1 ctxt (f:Format.formatter) (x:pattern) : unit = if x.ppat_attributes <> [] then pattern ctxt f x else match x.ppat_desc with | Ppat_variant (l, Some p) -> - pp f "@[<2>`%s@;%a@]" l (simple_pattern ctxt) p - | Ppat_construct (({txt=Lident("()"|"[]");_}), _) -> + pp f "@[<2>`%a@;%a@]" ident_of_name l (simple_pattern ctxt) p + | Ppat_construct (({txt=Lident("()"|"[]"|"true"|"false");_}), _) -> simple_pattern ctxt f x | Ppat_construct (({txt;_} as li), po) -> (* FIXME The third field always false *) @@ -448,7 +464,7 @@ and pattern1 ctxt (f:Format.formatter) (x:pattern) : unit = pp f "%a@;%a" longident_loc li (simple_pattern ctxt) x | Some (vl, x) -> pp f "%a@ (type %a)@;%a" longident_loc li - (list ~sep:"@ " string_loc) vl + (list ~sep:"@ " ident_of_name_loc) vl (simple_pattern ctxt) x | None -> pp f "%a" longident_loc li) | _ -> simple_pattern ctxt f x @@ -456,10 +472,10 @@ and pattern1 ctxt (f:Format.formatter) (x:pattern) : unit = and simple_pattern ctxt (f:Format.formatter) (x:pattern) : unit = if x.ppat_attributes <> [] then pattern ctxt f x else match x.ppat_desc with - | Ppat_construct (({txt=Lident ("()"|"[]" as x);_}), None) -> + | Ppat_construct (({txt=Lident ("()"|"[]"|"true"|"false" as x);_}), None) -> pp f "%s" x | Ppat_any -> pp f "_"; - | Ppat_var ({txt = txt;_}) -> protect_ident f txt + | Ppat_var ({txt = txt;_}) -> ident_of_name f txt | Ppat_array l -> pp f "@[<2>[|%a|]@]" (list (pattern1 ctxt) ~sep:";") l | Ppat_unpack { txt = None } -> @@ -489,7 +505,7 @@ and simple_pattern ctxt (f:Format.formatter) (x:pattern) : unit = pp f "@[<1>(%a)@]" (list ~sep:",@;" (pattern1 ctxt)) l (* level1*) | Ppat_constant (c) -> pp f "%a" constant c | Ppat_interval (c1, c2) -> pp f "%a..%a" constant c1 constant c2 - | Ppat_variant (l,None) -> pp f "`%s" l + | Ppat_variant (l,None) -> pp f "`%a" ident_of_name l | Ppat_constraint (p, ct) -> pp f "@[<2>(%a@;:@;%a)@]" (pattern1 ctxt) p (core_type ctxt) ct | Ppat_lazy p -> @@ -501,7 +517,8 @@ and simple_pattern ctxt (f:Format.formatter) (x:pattern) : unit = let with_paren = match p.ppat_desc with | Ppat_array _ | Ppat_record _ - | Ppat_construct (({txt=Lident ("()"|"[]");_}), None) -> false + | Ppat_construct (({txt=Lident ("()"|"[]"|"true"|"false");_}), None) -> + false | _ -> true in pp f "@[<2>%a.%a @]" longident_loc lid (paren with_paren @@ pattern1 ctxt) p @@ -517,20 +534,21 @@ and label_exp ctxt f (l,opt,p) = | {ppat_desc = Ppat_var {txt;_}; ppat_attributes = []} when txt = rest -> (match opt with - | Some o -> pp f "?(%s=@;%a)@;" rest (expression ctxt) o - | None -> pp f "?%s@ " rest) + | Some o -> + pp f "?(%a=@;%a)@;" ident_of_name rest (expression ctxt) o + | None -> pp f "?%a@ " ident_of_name rest) | _ -> (match opt with | Some o -> - pp f "?%s:(%a=@;%a)@;" - rest (pattern1 ctxt) p (expression ctxt) o - | None -> pp f "?%s:%a@;" rest (simple_pattern ctxt) p) + pp f "?%a:(%a=@;%a)@;" + ident_of_name rest (pattern1 ctxt) p (expression ctxt) o + | None -> pp f "?%a:%a@;" ident_of_name rest (simple_pattern ctxt) p) end | Labelled l -> match p with | {ppat_desc = Ppat_var {txt;_}; ppat_attributes = []} when txt = l -> - pp f "~%s@;" l - | _ -> pp f "~%s:%a@;" l (simple_pattern ctxt) p + pp f "~%a@;" ident_of_name l + | _ -> pp f "~%a:%a@;" ident_of_name l (simple_pattern ctxt) p and sugar_expr ctxt f e = if e.pexp_attributes <> [] then false @@ -608,18 +626,41 @@ and sugar_expr ctxt f e = end | _ -> false -and uncurry params e = - match e.pexp_desc with - | Pexp_fun (l, e0, p, e) -> - uncurry ((l, e0, p) :: params) e - | _ -> List.rev params, e +and function_param ctxt f param = + match param.pparam_desc with + | Pparam_val (a, b, c) -> label_exp ctxt f (a, b, c) + | Pparam_newtype ty -> pp f "(type %a)@;" ident_of_name ty.txt + +and function_body ctxt f function_body = + match function_body with + | Pfunction_body body -> expression ctxt f body + | Pfunction_cases (cases, _, attrs) -> + pp f "@[function%a%a@]" + (item_attributes ctxt) attrs + (case_list ctxt) cases + +and type_constraint ctxt f constraint_ = + match constraint_ with + | Pconstraint ty -> + pp f ":@;%a" (core_type ctxt) ty + | Pcoerce (ty1, ty2) -> + pp f "%a:>@;%a" + (option ~first:":@;" (core_type ctxt)) ty1 + (core_type ctxt) ty2 + +and function_params_then_body ctxt f params constraint_ body ~delimiter = + pp f "%a%a%s@;%a" + (list (function_param ctxt) ~sep:"") params + (option (type_constraint ctxt)) constraint_ + delimiter + (function_body (under_functionrhs ctxt)) body and expression ctxt f x = if x.pexp_attributes <> [] then pp f "((%a)@,%a)" (expression ctxt) {x with pexp_attributes=[]} (attributes ctxt) x.pexp_attributes else match x.pexp_desc with - | Pexp_function _ | Pexp_fun _ | Pexp_match _ | Pexp_try _ | Pexp_sequence _ + | Pexp_function _ | Pexp_match _ | Pexp_try _ | Pexp_sequence _ | Pexp_newtype _ when ctxt.pipe || ctxt.semi -> paren true (expression reset_ctxt) f x @@ -629,16 +670,34 @@ and expression ctxt f x = | Pexp_letexception _ | Pexp_letop _ when ctxt.semi -> paren true (expression reset_ctxt) f x - | Pexp_fun (l, e0, p, e) -> - let params, body = uncurry [l, e0, p] e in - pp f "@[<2>fun@;%a->@;%a@]" - (pp_print_list (label_exp ctxt)) params - (expression ctxt) body | Pexp_newtype (lid, e) -> - pp f "@[<2>fun@;(type@;%s)@;->@;%a@]" lid.txt + pp f "@[<2>fun@;(type@;%a)@;->@;%a@]" ident_of_name lid.txt (expression ctxt) e - | Pexp_function l -> - pp f "@[function%a@]" (case_list ctxt) l + | Pexp_function (params, c, body) -> + begin match params, c with + (* Omit [fun] if there are no params. *) + | [], None -> + (* If function cases are a direct body of a function, + the function node should be wrapped in parens so + it doesn't become part of the enclosing function. *) + let should_paren = + match body with + | Pfunction_cases _ -> ctxt.functionrhs + | Pfunction_body _ -> false + in + let ctxt' = if should_paren then reset_ctxt else ctxt in + pp f "@[<2>%a@]" (paren should_paren (function_body ctxt')) body + | [], Some c -> + pp f "@[<2>(%a@;%a)@]" + (function_body ctxt) body + (type_constraint ctxt) c + | _ :: _, _ -> + pp f "@[<2>fun@;%a@]" + (fun f () -> + function_params_then_body ctxt f params c body ~delimiter:"->") + (); + + end | Pexp_match (e, l) -> pp f "@[@[@[<2>match %a@]@ with@]%a@]" (expression reset_ctxt) e (case_list ctxt) l @@ -726,10 +785,10 @@ and expression ctxt f x = | Pexp_new (li) -> pp f "@[new@ %a@]" longident_loc li; | Pexp_setinstvar (s, e) -> - pp f "@[%s@ <-@ %a@]" s.txt (expression ctxt) e + pp f "@[%a@ <-@ %a@]" ident_of_name s.txt (expression ctxt) e | Pexp_override l -> (* FIXME *) let string_x_expression f (s, e) = - pp f "@[%s@ =@ %a@]" s.txt (expression ctxt) e in + pp f "@[%a@ =@ %a@]" ident_of_name s.txt (expression ctxt) e in pp f "@[{<%a>}@]" (list string_x_expression ~sep:";" ) l; | Pexp_letmodule (s, me, e) -> @@ -756,7 +815,7 @@ and expression ctxt f x = (override o.popen_override) (module_expr ctxt) o.popen_expr (expression ctxt) e | Pexp_variant (l,Some eo) -> - pp f "@[<2>`%s@;%a@]" l (simple_expr ctxt) eo + pp f "@[<2>`%a@;%a@]" ident_of_name l (simple_expr ctxt) eo | Pexp_letop {let_; ands; body} -> pp f "@[<2>@[%a@,%a@] in@;<1 -2>%a@]" (binding_op ctxt) let_ @@ -780,7 +839,8 @@ and expression2 ctxt f x = else match x.pexp_desc with | Pexp_field (e, li) -> pp f "@[%a.%a@]" (simple_expr ctxt) e longident_loc li - | Pexp_send (e, s) -> pp f "@[%a#%s@]" (simple_expr ctxt) e s.txt + | Pexp_send (e, s) -> + pp f "@[%a#%a@]" (simple_expr ctxt) e ident_of_name s.txt | _ -> simple_expr ctxt f x @@ -791,6 +851,8 @@ and simple_expr ctxt f x = (match view_expr x with | `nil -> pp f "[]" | `tuple -> pp f "()" + | `btrue -> pp f "true" + | `bfalse -> pp f "false" | `list xs -> pp f "@[[%a]@]" (list (expression (under_semi ctxt)) ~sep:";@;") xs @@ -812,7 +874,7 @@ and simple_expr ctxt f x = pp f "(%a%a :> %a)" (expression ctxt) e (option (core_type ctxt) ~first:" : " ~last:" ") cto1 (* no sep hint*) (core_type ctxt) ct - | Pexp_variant (l, None) -> pp f "`%s" l + | Pexp_variant (l, None) -> pp f "`%a" ident_of_name l | Pexp_record (l, eo) -> let longident_x_expression f ( li, e) = match e with @@ -882,12 +944,14 @@ and class_type_field ctxt f x = pp f "@[<2>inherit@ %a@]%a" (class_type ctxt) ct (item_attributes ctxt) x.pctf_attributes | Pctf_val (s, mf, vf, ct) -> - pp f "@[<2>val @ %a%a%s@ :@ %a@]%a" - mutable_flag mf virtual_flag vf s.txt (core_type ctxt) ct + pp f "@[<2>val @ %a%a%a@ :@ %a@]%a" + mutable_flag mf virtual_flag vf + ident_of_name s.txt (core_type ctxt) ct (item_attributes ctxt) x.pctf_attributes | Pctf_method (s, pf, vf, ct) -> - pp f "@[<2>method %a %a%s :@;%a@]%a" - private_flag pf virtual_flag vf s.txt (core_type ctxt) ct + pp f "@[<2>method %a %a%a :@;%a@]%a" + private_flag pf virtual_flag vf + ident_of_name s.txt (core_type ctxt) ct (item_attributes ctxt) x.pctf_attributes | Pctf_constraint (ct1, ct2) -> pp f "@[<2>constraint@ %a@ =@ %a@]%a" @@ -934,9 +998,10 @@ and class_type ctxt f x = and class_type_declaration_list ctxt f l = let class_type_declaration kwd f x = let { pci_params=ls; pci_name={ txt; _ }; _ } = x in - pp f "@[<2>%s %a%a%s@ =@ %a@]%a" kwd + pp f "@[<2>%s %a%a%a@ =@ %a@]%a" kwd virtual_flag x.pci_virt - (class_params_def ctxt) ls txt + (class_params_def ctxt) ls + ident_of_name txt (class_type ctxt) x.pci_expr (item_attributes ctxt) x.pci_attributes in @@ -955,21 +1020,24 @@ and class_field ctxt f x = (class_expr ctxt) ce (fun f so -> match so with | None -> (); - | Some (s) -> pp f "@ as %s" s.txt ) so + | Some (s) -> pp f "@ as %a" ident_of_name s.txt ) so (item_attributes ctxt) x.pcf_attributes | Pcf_val (s, mf, Cfk_concrete (ovf, e)) -> - pp f "@[<2>val%s %a%s =@;%a@]%a" (override ovf) - mutable_flag mf s.txt + pp f "@[<2>val%s %a%a =@;%a@]%a" (override ovf) + mutable_flag mf + ident_of_name s.txt (expression ctxt) e (item_attributes ctxt) x.pcf_attributes | Pcf_method (s, pf, Cfk_virtual ct) -> - pp f "@[<2>method virtual %a %s :@;%a@]%a" - private_flag pf s.txt + pp f "@[<2>method virtual %a %a :@;%a@]%a" + private_flag pf + ident_of_name s.txt (core_type ctxt) ct (item_attributes ctxt) x.pcf_attributes | Pcf_val (s, mf, Cfk_virtual ct) -> - pp f "@[<2>val virtual %a%s :@ %a@]%a" - mutable_flag mf s.txt + pp f "@[<2>val virtual %a%a :@ %a@]%a" + mutable_flag mf + ident_of_name s.txt (core_type ctxt) ct (item_attributes ctxt) x.pcf_attributes | Pcf_method (s, pf, Cfk_concrete (ovf, e)) -> @@ -981,6 +1049,7 @@ and class_field ctxt f x = ppat_loc_stack=[]; ppat_attributes=[]}; pvb_expr=e; + pvb_constraint=None; pvb_attributes=[]; pvb_loc=Location.none; } @@ -990,8 +1059,8 @@ and class_field ctxt f x = private_flag pf (fun f -> function | {pexp_desc=Pexp_poly (e, Some ct); pexp_attributes=[]; _} -> - pp f "%s :@;%a=@;%a" - s.txt (core_type ctxt) ct (expression ctxt) e + pp f "%a :@;%a=@;%a" + ident_of_name s.txt (core_type ctxt) ct (expression ctxt) e | {pexp_desc=Pexp_poly (e, None); pexp_attributes=[]; _} -> bind e | _ -> bind e) e @@ -1060,7 +1129,7 @@ and module_type ctxt f x = end else match x.pmty_desc with | Pmty_functor (Unit, mt2) -> - pp f "@[functor () ->@ %a@]" (module_type ctxt) mt2 + pp f "@[() ->@ %a@]" (module_type ctxt) mt2 | Pmty_functor (Named (s, mt1), mt2) -> begin match s.txt with | None -> @@ -1079,19 +1148,17 @@ and module_type ctxt f x = and with_constraint ctxt f = function | Pwith_type (li, ({ptype_params= ls ;_} as td)) -> - let ls = List.map fst ls in pp f "type@ %a %a =@ %a" - (list (core_type ctxt) ~sep:"," ~first:"(" ~last:")") - ls longident_loc li (type_declaration ctxt) td + (type_params ctxt) ls + longident_loc li (type_declaration ctxt) td | Pwith_module (li, li2) -> pp f "module %a =@ %a" longident_loc li longident_loc li2; | Pwith_modtype (li, mty) -> pp f "module type %a =@ %a" longident_loc li (module_type ctxt) mty; | Pwith_typesubst (li, ({ptype_params=ls;_} as td)) -> - let ls = List.map fst ls in pp f "type@ %a %a :=@ %a" - (list (core_type ctxt) ~sep:"," ~first:"(" ~last:")") - ls longident_loc li + (type_params ctxt) ls + longident_loc li (type_declaration ctxt) td | Pwith_modsubst (li, li2) -> pp f "module %a :=@ %a" longident_loc li longident_loc li2 @@ -1128,7 +1195,7 @@ and signature_item ctxt f x : unit = | Psig_value vd -> let intro = if vd.pval_prim = [] then "val" else "external" in pp f "@[<2>%s@ %a@ :@ %a@]%a" intro - protect_ident vd.pval_name.txt + ident_of_name vd.pval_name.txt (value_description ctxt) vd (item_attributes ctxt) vd.pval_attributes | Psig_typext te -> @@ -1137,9 +1204,10 @@ and signature_item ctxt f x : unit = exception_declaration ctxt f ed | Psig_class l -> let class_description kwd f ({pci_params=ls;pci_name={txt;_};_} as x) = - pp f "@[<2>%s %a%a%s@;:@;%a@]%a" kwd + pp f "@[<2>%s %a%a%a@;:@;%a@]%a" kwd virtual_flag x.pci_virt - (class_params_def ctxt) ls txt + (class_params_def ctxt) ls + ident_of_name txt (class_type ctxt) x.pci_expr (item_attributes ctxt) x.pci_attributes in begin @@ -1239,6 +1307,8 @@ and module_expr ctxt f x = | Pmod_apply (me1, me2) -> pp f "(%a)(%a)" (module_expr ctxt) me1 (module_expr ctxt) me2 (* Cf: #7200 *) + | Pmod_apply_unit me1 -> + pp f "(%a)()" (module_expr ctxt) me1 | Pmod_unpack e -> pp f "(val@ %a)" (expression ctxt) e | Pmod_extension ({ txt; _ }, _) when txt = Ast_helper.hole_txt -> @@ -1261,77 +1331,37 @@ and payload ctxt f = function pp f " when "; expression ctxt f e (* transform [f = fun g h -> ..] to [f g h = ... ] could be improved *) -and binding ctxt f {pvb_pat=p; pvb_expr=x; _} = +and binding ctxt f {pvb_pat=p; pvb_expr=x; pvb_constraint = ct; _} = (* .pvb_attributes have already been printed by the caller, #bindings *) let rec pp_print_pexp_function f x = if x.pexp_attributes <> [] then pp f "=@;%a" (expression ctxt) x else match x.pexp_desc with - | Pexp_fun (label, eo, p, e) -> - if label=Nolabel then - pp f "%a@ %a" (simple_pattern ctxt) p pp_print_pexp_function e - else - pp f "%a@ %a" - (label_exp ctxt) (label,eo,p) pp_print_pexp_function e + | Pexp_function (params, c, body) -> + function_params_then_body ctxt f params c body ~delimiter:"=" | Pexp_newtype (str,e) -> - pp f "(type@ %s)@ %a" str.txt pp_print_pexp_function e + pp f "(type@ %a)@ %a" ident_of_name str.txt pp_print_pexp_function e | _ -> pp f "=@;%a" (expression ctxt) x in - let tyvars_str tyvars = List.map (fun v -> v.txt) tyvars in - let is_desugared_gadt p e = - let gadt_pattern = - match p with - | {ppat_desc=Ppat_constraint({ppat_desc=Ppat_var _} as pat, - {ptyp_desc=Ptyp_poly (args_tyvars, rt)}); - ppat_attributes=[]}-> - Some (pat, args_tyvars, rt) - | _ -> None in - let rec gadt_exp tyvars e = - match e with - | {pexp_desc=Pexp_newtype (tyvar, e); pexp_attributes=[]} -> - gadt_exp (tyvar :: tyvars) e - | {pexp_desc=Pexp_constraint (e, ct); pexp_attributes=[]} -> - Some (List.rev tyvars, e, ct) - | _ -> None in - let gadt_exp = gadt_exp [] e in - match gadt_pattern, gadt_exp with - | Some (p, pt_tyvars, pt_ct), Some (e_tyvars, e, e_ct) - when tyvars_str pt_tyvars = tyvars_str e_tyvars -> - let ety = Typ.varify_constructors e_tyvars e_ct in - if ety = pt_ct then - Some (p, pt_tyvars, e_ct, e) else None - | _ -> None in - if x.pexp_attributes <> [] - then - match p with - | {ppat_desc=Ppat_constraint({ppat_desc=Ppat_var _; _} as pat, - ({ptyp_desc=Ptyp_poly _; _} as typ)); - ppat_attributes=[]; _} -> - pp f "%a@;: %a@;=@;%a" - (simple_pattern ctxt) pat (core_type ctxt) typ (expression ctxt) x - | _ -> - pp f "%a@;=@;%a" (pattern ctxt) p (expression ctxt) x - else - match is_desugared_gadt p x with - | Some (p, [], ct, e) -> - pp f "%a@;: %a@;=@;%a" - (simple_pattern ctxt) p (core_type ctxt) ct (expression ctxt) e - | Some (p, tyvars, ct, e) -> begin - pp f "%a@;: type@;%a.@;%a@;=@;%a" - (simple_pattern ctxt) p (list pp_print_string ~sep:"@;") - (tyvars_str tyvars) (core_type ctxt) ct (expression ctxt) e - end + match ct with + | Some (Pvc_constraint { locally_abstract_univars = []; typ }) -> + pp f "%a@;:@;%a@;=@;%a" + (simple_pattern ctxt) p (core_type ctxt) typ (expression ctxt) x + | Some (Pvc_constraint { locally_abstract_univars = vars; typ }) -> + pp f "%a@;: type@;%a.@;%a@;=@;%a" + (simple_pattern ctxt) p (list pp_print_string ~sep:"@;") + (List.map (fun x -> x.txt) vars) + (core_type ctxt) typ (expression ctxt) x + | Some (Pvc_coercion {ground=None; coercion }) -> + pp f "%a@;:>@;%a@;=@;%a" + (simple_pattern ctxt) p (core_type ctxt) coercion (expression ctxt) x + | Some (Pvc_coercion {ground=Some ground; coercion }) -> + pp f "%a@;:%a@;:>@;%a@;=@;%a" + (simple_pattern ctxt) p + (core_type ctxt) ground + (core_type ctxt) coercion + (expression ctxt) x | None -> begin match p with - | {ppat_desc=Ppat_constraint(p ,ty); - ppat_attributes=[]} -> (* special case for the first*) - begin match ty with - | {ptyp_desc=Ptyp_poly _; ptyp_attributes=[]} -> - pp f "%a@;:@;%a@;=@;%a" (simple_pattern ctxt) p - (core_type ctxt) ty (expression ctxt) x - | _ -> - pp f "(%a@;:@;%a)@;=@;%a" (simple_pattern ctxt) p - (core_type ctxt) ty (expression ctxt) x - end | {ppat_desc=Ppat_var _; ppat_attributes=[]} -> pp f "%a@ %a" (simple_pattern ctxt) p pp_print_pexp_function x | _ -> @@ -1438,9 +1468,10 @@ and structure_item ctxt f x = let class_declaration kwd f ({pci_params=ls; pci_name={txt;_}; _} as x) = let args, constr, cl = extract_class_args x.pci_expr in - pp f "@[<2>%s %a%a%s %a%a=@;%a@]%a" kwd + pp f "@[<2>%s %a%a%a %a%a=@;%a@]%a" kwd virtual_flag x.pci_virt - (class_params_def ctxt) ls txt + (class_params_def ctxt) ls + ident_of_name txt (list (label_exp ctxt)) args (option class_constraint) constr (class_expr ctxt) cl @@ -1457,7 +1488,7 @@ and structure_item ctxt f x = | Pstr_class_type l -> class_type_declaration_list ctxt f l | Pstr_primitive vd -> pp f "@[external@ %a@ :@ %a@]%a" - protect_ident vd.pval_name.txt + ident_of_name vd.pval_name.txt (value_description ctxt) vd (item_attributes ctxt) vd.pval_attributes | Pstr_include incl -> @@ -1514,10 +1545,11 @@ and type_def_list ctxt f (rf, exported, l) = else if exported then " =" else " :=" in - pp f "@[<2>%s %a%a%s%s%a@]%a" kwd + pp f "@[<2>%s %a%a%a%s%a@]%a" kwd nonrec_flag rf (type_params ctxt) x.ptype_params - x.ptype_name.txt eq + ident_of_name x.ptype_name.txt + eq (type_declaration ctxt) x (item_attributes ctxt) x.ptype_attributes in @@ -1530,9 +1562,9 @@ and type_def_list ctxt f (rf, exported, l) = and record_declaration ctxt f lbls = let type_record_field f pld = - pp f "@[<2>%a%s:@;%a@;%a@]" + pp f "@[<2>%a%a:@;%a@;%a@]" mutable_flag pld.pld_mutable - pld.pld_name.txt + ident_of_name pld.pld_name.txt (core_type ctxt) pld.pld_type (attributes ctxt) pld.pld_attributes in @@ -1664,14 +1696,14 @@ and label_x_expression_param ctxt f (l,e) = | Nolabel -> expression2 ctxt f e (* level 2*) | Optional str -> if Some str = simple_name then - pp f "?%s" str + pp f "?%a" ident_of_name str else - pp f "?%s:%a" str (simple_expr ctxt) e + pp f "?%a:%a" ident_of_name str (simple_expr ctxt) e | Labelled lbl -> if Some lbl = simple_name then - pp f "~%s" lbl + pp f "~%a" ident_of_name lbl else - pp f "~%s:%a" lbl (simple_expr ctxt) e + pp f "~%a:%a" ident_of_name lbl (simple_expr ctxt) e and directive_argument f x = match x.pdira_desc with @@ -1729,6 +1761,8 @@ let binding = binding reset_ctxt let payload = payload reset_ctxt let case_list = case_list reset_ctxt +module Style = Misc.Style +(* merlin: moved from parse.ml *) let prepare_error err = let source = Location.Parser in let open Syntaxerr in @@ -1739,31 +1773,58 @@ let prepare_error err = ~loc:closing_loc ~sub:[ Location.msg ~loc:opening_loc - "This '%s' might be unmatched" opening + "This %a might be unmatched" Style.inline_code opening ] - "Syntax error: '%s' expected" closing + "Syntax error: %a expected" Style.inline_code closing | Expecting (loc, nonterm) -> - Location.errorf ~source ~loc "Syntax error: %s expected." nonterm + Location.errorf ~source ~loc "Syntax error: %a expected." + Style.inline_code nonterm | Not_expecting (loc, nonterm) -> - Location.errorf ~source ~loc "Syntax error: %s not expected." nonterm + Location.errorf ~source ~loc "Syntax error: %a not expected." + Style.inline_code nonterm | Applicative_path loc -> Location.errorf ~source ~loc - "Syntax error: applicative paths of the form F(X).t \ - are not supported when the option -no-app-func is set." + "Syntax error: applicative paths of the form %a \ + are not supported when the option %a is set." + Style.inline_code "F(X).t" + Style.inline_code "-no-app-func" | Variable_in_scope (loc, var) -> Location.errorf ~source ~loc "In this scoped type, variable %a \ - is reserved for the local type %s." - tyvar var var + is reserved for the local type %a." + (Style.as_inline_code tyvar) var + Style.inline_code var | Other loc -> Location.errorf ~source ~loc "Syntax error" | Ill_formed_ast (loc, s) -> - Location.errorf ~loc + Location.errorf ~source ~loc "broken invariant in parsetree: %s" s - | Invalid_package_type (loc, s) -> - Location.errorf ~source ~loc "invalid package type: %s" s - + | Invalid_package_type (loc, ipt) -> + let invalid ppf ipt = match ipt with + | Syntaxerr.Parameterized_types -> + Format.fprintf ppf "parametrized types are not supported" + | Constrained_types -> + Format.fprintf ppf "constrained types are not supported" + | Private_types -> + Format.fprintf ppf "private types are not supported" + | Not_with_type -> + Format.fprintf ppf "only %a constraints are supported" + Style.inline_code "with type t =" + | Neither_identifier_nor_with_type -> + Format.fprintf ppf + "only module type identifier and %a constraints are supported" + Style.inline_code "with type" + in + Location.errorf ~source ~loc "invalid package type: %a" invalid ipt + | Removed_string_set loc -> + Location.errorf ~source ~loc + "Syntax error: strings are immutable, there is no assignment \ + syntax for them.\n\ + @{Hint@}: Mutable sequences of bytes are available in \ + the Bytes module.\n\ + @{Hint@}: Did you mean to use %a?" + Style.inline_code "Bytes.set" let () = Location.register_error_of_exn (function diff --git a/src/ocaml/parsing/pprintast.mli b/src/ocaml/parsing/pprintast.mli index c9f5393dc2..bf73501394 100644 --- a/src/ocaml/parsing/pprintast.mli +++ b/src/ocaml/parsing/pprintast.mli @@ -50,11 +50,17 @@ val signature_item: Format.formatter -> Parsetree.signature_item -> unit val binding: Format.formatter -> Parsetree.value_binding -> unit val payload: Format.formatter -> Parsetree.payload -> unit +val tyvar_of_name : string -> string + (** Turn a type variable name into a valid identifier, taking care of the + special treatment required for the single quote character in second + position, or for keywords by escaping them with \#. No-op on "_". *) + val tyvar: Format.formatter -> string -> unit - (** Print a type variable name, taking care of the special treatment - required for the single quote character in second position. *) + (** Print a type variable name as a valid identifier, taking care of the + special treatment required for the single quote character in second + position, or for keywords by escaping them with \#. No-op on "_". *) (* merlin *) val case_list : Format.formatter -> Parsetree.case list -> unit -val protect_ident : Format.formatter -> string -> unit +val ident_of_name : Format.formatter -> string -> unit val needs_parens : string -> bool diff --git a/src/ocaml/parsing/printast.ml b/src/ocaml/parsing/printast.ml index 83f1cd98ba..d7d569214e 100644 --- a/src/ocaml/parsing/printast.ml +++ b/src/ocaml/parsing/printast.ml @@ -13,11 +13,11 @@ (* *) (**************************************************************************) -open Asttypes;; -open Format;; -open Lexing;; -open Location;; -open Parsetree;; +open Asttypes +open Format +open Lexing +open Location +open Parsetree let fmt_position with_name f l = let fname = if with_name then l.pos_fname else "" in @@ -25,7 +25,7 @@ let fmt_position with_name f l = then fprintf f "%s[%d]" fname l.pos_cnum else fprintf f "%s[%d,%d+%d]" fname l.pos_lnum l.pos_bol (l.pos_cnum - l.pos_bol) -;; + let fmt_location f loc = if not !Clflags.locations then () @@ -35,29 +35,25 @@ let fmt_location f loc = (fmt_position p_2nd_name) loc.loc_end; if loc.loc_ghost then fprintf f " ghost"; end -;; + let rec fmt_longident_aux f x = match x with - | Longident.Lident (s) -> fprintf f "%s" s; - | Longident.Ldot (y, s) -> fprintf f "%a.%s" fmt_longident_aux y s; + | Longident.Lident (s) -> fprintf f "%s" s + | Longident.Ldot (y, s) -> fprintf f "%a.%s" fmt_longident_aux y s | Longident.Lapply (y, z) -> - fprintf f "%a(%a)" fmt_longident_aux y fmt_longident_aux z; -;; + fprintf f "%a(%a)" fmt_longident_aux y fmt_longident_aux z -let fmt_longident f x = fprintf f "\"%a\"" fmt_longident_aux x;; +let fmt_longident f x = fprintf f "\"%a\"" fmt_longident_aux x let fmt_longident_loc f (x : Longident.t loc) = - fprintf f "\"%a\" %a" fmt_longident_aux x.txt fmt_location x.loc; -;; + fprintf f "\"%a\" %a" fmt_longident_aux x.txt fmt_location x.loc let fmt_string_loc f (x : string loc) = - fprintf f "\"%s\" %a" x.txt fmt_location x.loc; -;; + fprintf f "\"%s\" %a" x.txt fmt_location x.loc let fmt_str_opt_loc f (x : string option loc) = - fprintf f "\"%s\" %a" (Option.value x.txt ~default:"_") fmt_location x.loc; -;; + fprintf f "\"%s\" %a" (Option.value x.txt ~default:"_") fmt_location x.loc let fmt_char_option f = function | None -> fprintf f "None" @@ -66,31 +62,27 @@ let fmt_char_option f = function let fmt_constant f x = match x with | Pconst_integer (i,m) -> fprintf f "PConst_int (%s,%a)" i fmt_char_option m; - | Pconst_char (c) -> fprintf f "PConst_char %02x" (Char.code c); + | Pconst_char (c) -> fprintf f "PConst_char %02x" (Char.code c) | Pconst_string (s, strloc, None) -> - fprintf f "PConst_string(%S,%a,None)" s fmt_location strloc ; + fprintf f "PConst_string(%S,%a,None)" s fmt_location strloc | Pconst_string (s, strloc, Some delim) -> - fprintf f "PConst_string (%S,%a,Some %S)" s fmt_location strloc delim; - | Pconst_float (s,m) -> fprintf f "PConst_float (%s,%a)" s fmt_char_option m; -;; + fprintf f "PConst_string (%S,%a,Some %S)" s fmt_location strloc delim + | Pconst_float (s,m) -> fprintf f "PConst_float (%s,%a)" s fmt_char_option m let fmt_mutable_flag f x = match x with - | Immutable -> fprintf f "Immutable"; - | Mutable -> fprintf f "Mutable"; -;; + | Immutable -> fprintf f "Immutable" + | Mutable -> fprintf f "Mutable" let fmt_virtual_flag f x = match x with - | Virtual -> fprintf f "Virtual"; - | Concrete -> fprintf f "Concrete"; -;; + | Virtual -> fprintf f "Virtual" + | Concrete -> fprintf f "Concrete" let fmt_override_flag f x = match x with - | Override -> fprintf f "Override"; - | Fresh -> fprintf f "Fresh"; -;; + | Override -> fprintf f "Override" + | Fresh -> fprintf f "Fresh" let fmt_closed_flag f x = match x with @@ -99,53 +91,47 @@ let fmt_closed_flag f x = let fmt_rec_flag f x = match x with - | Nonrecursive -> fprintf f "Nonrec"; - | Recursive -> fprintf f "Rec"; -;; + | Nonrecursive -> fprintf f "Nonrec" + | Recursive -> fprintf f "Rec" let fmt_direction_flag f x = match x with - | Upto -> fprintf f "Up"; - | Downto -> fprintf f "Down"; -;; + | Upto -> fprintf f "Up" + | Downto -> fprintf f "Down" let fmt_private_flag f x = match x with - | Public -> fprintf f "Public"; - | Private -> fprintf f "Private"; -;; + | Public -> fprintf f "Public" + | Private -> fprintf f "Private" let line i f s (*...*) = fprintf f "%s" (String.make ((2*i) mod 72) ' '); fprintf f s (*...*) -;; let list i f ppf l = match l with - | [] -> line i ppf "[]\n"; + | [] -> line i ppf "[]\n" | _ :: _ -> line i ppf "[\n"; List.iter (f (i+1) ppf) l; - line i ppf "]\n"; -;; + line i ppf "]\n" let option i f ppf x = match x with - | None -> line i ppf "None\n"; + | None -> line i ppf "None\n" | Some x -> line i ppf "Some\n"; - f (i+1) ppf x; -;; + f (i+1) ppf x -let longident_loc i ppf li = line i ppf "%a\n" fmt_longident_loc li;; -let string i ppf s = line i ppf "\"%s\"\n" s;; -let string_loc i ppf s = line i ppf "%a\n" fmt_string_loc s;; -let str_opt_loc i ppf s = line i ppf "%a\n" fmt_str_opt_loc s;; +let longident_loc i ppf li = line i ppf "%a\n" fmt_longident_loc li +let string i ppf s = line i ppf "\"%s\"\n" s +let string_loc i ppf s = line i ppf "%a\n" fmt_string_loc s +let str_opt_loc i ppf s = line i ppf "%a\n" fmt_str_opt_loc s let arg_label i ppf = function | Nolabel -> line i ppf "Nolabel\n" | Optional s -> line i ppf "Optional \"%s\"\n" s | Labelled s -> line i ppf "Labelled \"%s\"\n" s -;; + let typevars ppf vs = List.iter (fun x -> fprintf ppf " %a" Pprintast.tyvar x.txt) vs @@ -189,7 +175,7 @@ let rec core_type i ppf x = line i ppf "Ptyp_class %a\n" fmt_longident_loc li; list i core_type ppf l | Ptyp_alias (ct, s) -> - line i ppf "Ptyp_alias \"%s\"\n" s; + line i ppf "Ptyp_alias \"%s\"\n" s.txt; core_type i ppf ct; | Ptyp_poly (sl, ct) -> line i ppf "Ptyp_poly%a\n" typevars sl; @@ -197,6 +183,9 @@ let rec core_type i ppf x = | Ptyp_package (s, l) -> line i ppf "Ptyp_package %a\n" fmt_longident_loc s; list i package_with ppf l; + | Ptyp_open (mod_ident, t) -> + line i ppf "Ptyp_open \"%a\"\n" fmt_longident_loc mod_ident; + core_type i ppf t | Ptyp_extension (s, arg) -> line i ppf "Ptyp_extension \"%s\"\n" s.txt; payload i ppf arg @@ -274,15 +263,11 @@ and expression i ppf x = line i ppf "Pexp_let %a\n" fmt_rec_flag rf; list i value_binding ppf l; expression i ppf e; - | Pexp_function l -> + | Pexp_function (params, c, body) -> line i ppf "Pexp_function\n"; - list i case ppf l; - | Pexp_fun (l, eo, p, e) -> - line i ppf "Pexp_fun\n"; - arg_label i ppf l; - option i expression ppf eo; - pattern i ppf p; - expression i ppf e; + list i function_param ppf params; + option i type_constraint ppf c; + function_body i ppf body | Pexp_apply (e, l) -> line i ppf "Pexp_apply\n"; expression i ppf e; @@ -400,6 +385,36 @@ and expression i ppf x = | Pexp_unreachable -> line i ppf "Pexp_unreachable" +and function_param i ppf { pparam_desc = desc; pparam_loc = loc } = + match desc with + | Pparam_val (l, eo, p) -> + line i ppf "Pparam_val %a\n" fmt_location loc; + arg_label (i+1) ppf l; + option (i+1) expression ppf eo; + pattern (i+1) ppf p + | Pparam_newtype ty -> + line i ppf "Pparam_newtype \"%s\" %a\n" ty.txt fmt_location loc + +and function_body i ppf body = + match body with + | Pfunction_body e -> + line i ppf "Pfunction_body\n"; + expression (i+1) ppf e + | Pfunction_cases (cases, loc, attrs) -> + line i ppf "Pfunction_cases %a\n" fmt_location loc; + attributes (i+1) ppf attrs; + list (i+1) case ppf cases + +and type_constraint i ppf constraint_ = + match constraint_ with + | Pconstraint ty -> + line i ppf "Pconstraint\n"; + core_type (i+1) ppf ty + | Pcoerce (ty1, ty2) -> + line i ppf "Pcoerce\n"; + option (i+1) core_type ppf ty1; + core_type (i+1) ppf ty2 + and value_description i ppf x = line i ppf "value_description %a %a\n" fmt_string_loc x.pval_name fmt_location x.pval_loc; @@ -804,6 +819,9 @@ and module_expr i ppf x = line i ppf "Pmod_apply\n"; module_expr i ppf me1; module_expr i ppf me2; + | Pmod_apply_unit me1 -> + line i ppf "Pmod_apply_unit\n"; + module_expr i ppf me1 | Pmod_constraint (me, mt) -> line i ppf "Pmod_constraint\n"; module_expr i ppf me; @@ -923,8 +941,23 @@ and value_binding i ppf x = line i ppf "\n"; attributes (i+1) ppf x.pvb_attributes; pattern (i+1) ppf x.pvb_pat; + Option.iter (value_constraint (i+1) ppf) x.pvb_constraint; expression (i+1) ppf x.pvb_expr +and value_constraint i ppf x = + let pp_sep ppf () = Format.fprintf ppf "@ "; in + let pp_newtypes = Format.pp_print_list fmt_string_loc ~pp_sep in + match x with + | Pvc_constraint { locally_abstract_univars = []; typ } -> + core_type i ppf typ + | Pvc_constraint { locally_abstract_univars=newtypes; typ} -> + line i ppf " %a.\n" pp_newtypes newtypes; + core_type i ppf typ + | Pvc_coercion { ground; coercion} -> + line i ppf "\n"; + option i core_type ppf ground; + core_type i ppf coercion; + and binding_op i ppf x = line i ppf " %a %a" fmt_string_loc x.pbop_op fmt_location x.pbop_loc; @@ -953,7 +986,7 @@ and label_x_bool_x_core_type_list i ppf x = | Rinherit (ct) -> line i ppf "Rinherit\n"; core_type (i+1) ppf ct -;; + let rec toplevel_phrase i ppf x = match x with @@ -968,15 +1001,14 @@ let rec toplevel_phrase i ppf x = and directive_argument i ppf x = match x.pdira_desc with - | Pdir_string (s) -> line i ppf "Pdir_string \"%s\"\n" s; - | Pdir_int (n, None) -> line i ppf "Pdir_int %s\n" n; - | Pdir_int (n, Some m) -> line i ppf "Pdir_int %s%c\n" n m; - | Pdir_ident (li) -> line i ppf "Pdir_ident %a\n" fmt_longident li; - | Pdir_bool (b) -> line i ppf "Pdir_bool %s\n" (string_of_bool b); -;; + | Pdir_string (s) -> line i ppf "Pdir_string \"%s\"\n" s + | Pdir_int (n, None) -> line i ppf "Pdir_int %s\n" n + | Pdir_int (n, Some m) -> line i ppf "Pdir_int %s%c\n" n m + | Pdir_ident (li) -> line i ppf "Pdir_ident %a\n" fmt_longident li + | Pdir_bool (b) -> line i ppf "Pdir_bool %s\n" (string_of_bool b) -let interface ppf x = list 0 signature_item ppf x;; +let interface ppf x = list 0 signature_item ppf x -let implementation ppf x = list 0 structure_item ppf x;; +let implementation ppf x = list 0 structure_item ppf x -let top_phrase ppf x = toplevel_phrase 0 ppf x;; +let top_phrase ppf x = toplevel_phrase 0 ppf x diff --git a/src/ocaml/parsing/printast.mli b/src/ocaml/parsing/printast.mli index 8215654826..5bc496182f 100644 --- a/src/ocaml/parsing/printast.mli +++ b/src/ocaml/parsing/printast.mli @@ -20,12 +20,12 @@ *) -open Parsetree;; -open Format;; +open Parsetree +open Format -val interface : formatter -> signature_item list -> unit;; -val implementation : formatter -> structure_item list -> unit;; -val top_phrase : formatter -> toplevel_phrase -> unit;; +val interface : formatter -> signature_item list -> unit +val implementation : formatter -> structure_item list -> unit +val top_phrase : formatter -> toplevel_phrase -> unit val expression: int -> formatter -> expression -> unit val structure: int -> formatter -> structure -> unit diff --git a/src/ocaml/parsing/syntaxerr.ml b/src/ocaml/parsing/syntaxerr.ml index 49372b9edf..8a326c1104 100644 --- a/src/ocaml/parsing/syntaxerr.ml +++ b/src/ocaml/parsing/syntaxerr.ml @@ -15,6 +15,13 @@ (* Auxiliary type for reporting syntax errors *) +type invalid_package_type = + | Parameterized_types + | Constrained_types + | Private_types + | Not_with_type + | Neither_identifier_nor_with_type + type error = Unclosed of Location.t * string * Location.t * string | Expecting of Location.t * string @@ -23,7 +30,8 @@ type error = | Variable_in_scope of Location.t * string | Other of Location.t | Ill_formed_ast of Location.t * string - | Invalid_package_type of Location.t * string + | Invalid_package_type of Location.t * invalid_package_type + | Removed_string_set of Location.t exception Error of error exception Escape_error @@ -36,7 +44,8 @@ let location_of_error = function | Not_expecting (l, _) | Ill_formed_ast (l, _) | Invalid_package_type (l, _) - | Expecting (l, _) -> l + | Expecting (l, _) + | Removed_string_set l -> l let ill_formed_ast loc s = diff --git a/src/ocaml/parsing/syntaxerr.mli b/src/ocaml/parsing/syntaxerr.mli index 26ba712671..a84bc6664c 100644 --- a/src/ocaml/parsing/syntaxerr.mli +++ b/src/ocaml/parsing/syntaxerr.mli @@ -20,6 +20,13 @@ *) +type invalid_package_type = + | Parameterized_types + | Constrained_types + | Private_types + | Not_with_type + | Neither_identifier_nor_with_type + type error = Unclosed of Location.t * string * Location.t * string | Expecting of Location.t * string @@ -28,7 +35,8 @@ type error = | Variable_in_scope of Location.t * string | Other of Location.t | Ill_formed_ast of Location.t * string - | Invalid_package_type of Location.t * string + | Invalid_package_type of Location.t * invalid_package_type + | Removed_string_set of Location.t exception Error of error exception Escape_error diff --git a/src/ocaml/parsing/unit_info.ml b/src/ocaml/parsing/unit_info.ml new file mode 100644 index 0000000000..03e8d44949 --- /dev/null +++ b/src/ocaml/parsing/unit_info.ml @@ -0,0 +1,122 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Florian Angeletti, projet Cambium, Inria Paris *) +(* *) +(* Copyright 2023 Institut National de Recherche en Informatique et *) +(* en Automatique. *) +(* *) +(* All rights reserved. This file is distributed under the terms of *) +(* the GNU Lesser General Public License version 2.1, with the *) +(* special exception on linking described in the file LICENSE. *) +(* *) +(**************************************************************************) + +type modname = string +type filename = string +type file_prefix = string + +type t = { + source_file: filename; + prefix: file_prefix; + modname: modname; +} + +let source_file (x: t) = x.source_file +let modname (x: t) = x.modname +let prefix (x: t) = x.prefix + +let basename_chop_extensions basename = + match String.index basename '.' with + | dot_pos -> String.sub basename 0 dot_pos + | exception Not_found -> basename + +let modulize s = String.capitalize_ascii s + +(* We re-export the [Misc] definition *) +let normalize = Misc.normalized_unit_filename + +let modname_from_source source_file = + source_file |> Filename.basename |> basename_chop_extensions |> modulize + +let start_char = function + | 'A' .. 'Z' -> true + | _ -> false + +let is_identchar_latin1 = function + | 'A'..'Z' | 'a'..'z' | '_' | '\192'..'\214' | '\216'..'\246' + | '\248'..'\255' | '\'' | '0'..'9' -> true + | _ -> false + +(* Check validity of module name *) +let is_unit_name name = + String.length name > 0 + && start_char name.[0] + && String.for_all is_identchar_latin1 name + +let check_unit_name file = + if not (is_unit_name (modname file)) then + Location.prerr_warning (Location.in_file (source_file file)) + (Warnings.Bad_module_name (modname file)) + +let make ?(check_modname=true) ~source_file prefix = + let modname = modname_from_source prefix in + let p = { modname; prefix; source_file } in + if check_modname then check_unit_name p; + p + +module Artifact = struct + type t = + { + source_file: filename option; + filename: filename; + modname: modname; + } + let source_file x = x.source_file + let filename x = x.filename + let modname x = x.modname + let prefix x = Filename.remove_extension (filename x) + + let from_filename filename = + let modname = modname_from_source filename in + { modname; filename; source_file = None } + +end + +let mk_artifact ext u = + { + Artifact.filename = u.prefix ^ ext; + modname = u.modname; + source_file = Some u.source_file; + } + +let companion_artifact ext x = + { x with Artifact.filename = Artifact.prefix x ^ ext } + +let cmi f = mk_artifact ".cmi" f +let cmo f = mk_artifact ".cmo" f +let cmx f = mk_artifact ".cmx" f +let obj f = mk_artifact Config.ext_obj f +let cmt f = mk_artifact ".cmt" f +let cmti f = mk_artifact ".cmti" f +let annot f = mk_artifact ".annot" f + +let companion_obj f = companion_artifact Config.ext_obj f +let companion_cmt f = companion_artifact ".cmt" f + +let companion_cmi f = + let prefix = Misc.chop_extensions f.Artifact.filename in + { f with Artifact.filename = prefix ^ ".cmi"} + +let mli_from_artifact f = Artifact.prefix f ^ !Config.interface_suffix +let mli_from_source u = + let prefix = Filename.remove_extension (source_file u) in + prefix ^ !Config.interface_suffix + +let is_cmi f = Filename.check_suffix (Artifact.filename f) ".cmi" + +let find_normalized_cmi f = + let filename = modname f ^ ".cmi" in + let filename = Load_path.find_normalized filename in + { Artifact.filename; modname = modname f; source_file = Some f.source_file } diff --git a/src/ocaml/parsing/unit_info.mli b/src/ocaml/parsing/unit_info.mli new file mode 100644 index 0000000000..466a07a228 --- /dev/null +++ b/src/ocaml/parsing/unit_info.mli @@ -0,0 +1,159 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Florian Angeletti, projet Cambium, Inria Paris *) +(* *) +(* Copyright 2023 Institut National de Recherche en Informatique et *) +(* en Automatique. *) +(* *) +(* All rights reserved. This file is distributed under the terms of *) +(* the GNU Lesser General Public License version 2.1, with the *) +(* special exception on linking described in the file LICENSE. *) +(* *) +(**************************************************************************) + +(** This module centralize the handling of compilation files and their metadata. + + Maybe more importantly, this module provides functions for deriving module + names from strings or filenames. +*) + +(** {1:modname_from_strings Module name convention and computation} *) + +type modname = string +type filename = string +type file_prefix = string + +(** [modulize s] capitalizes the first letter of [s]. *) +val modulize: string -> modname + +(** [normalize s] uncapitalizes the first letter of [s]. *) +val normalize: string -> string + +(** [modname_from_source filename] is [modulize stem] where [stem] is the + basename of the filename [filename] stripped from all its extensions. + For instance, [modname_from_source "/pa.th/x.ml.pp"] is ["X"]. *) +val modname_from_source: filename -> modname + +(** {2:module_name_validation Module name validation function}*) + +(** [is_unit_name ~strict name] is true only if [name] can be used as a + valid module name. *) +val is_unit_name : modname -> bool + + +(** {1:unit_info Metadata for compilation unit} *) + +type t +(** Metadata for a compilation unit: + - the module name associated to the unit + - the filename prefix (dirname + basename with all extensions stripped) + for compilation artifacts + - the input source file + For instance, when calling [ocamlopt dir/x.mli -o target/y.cmi], + - the input source file is [dir/x.mli] + - the module name is [Y] + - the prefix is [target/y] +*) + +(** [source_file u] is the source file of [u]. *) +val source_file: t -> filename + +(** [prefix u] is the filename prefix of the unit. *) +val prefix: t -> file_prefix + +(** [modname u] or [artifact_modname a] is the module name of the unit + or compilation artifact.*) +val modname: t -> modname + +(** [check_unit_name u] prints a warning if the derived module name [modname u] + should not be used as a module name as specified + by {!is_unit_name}[ ~strict:true]. *) +val check_unit_name : t -> unit + +(** [make ~check ~source_file prefix] associates both the + [source_file] and the module name {!modname_from_source}[ target_prefix] to + the prefix filesystem path [prefix]. + + If [check_modname=true], this function emits a warning if the derived module + name is not valid according to {!check_unit_name}. +*) +val make: ?check_modname:bool -> source_file:filename -> file_prefix -> t + +(** {1:artifact_function Build artifacts }*) +module Artifact: sig + type t +(** Metadata for a single compilation artifact: + - the module name associated to the artifact + - the filesystem path + - the input source file if it exists +*) + + (** [source_file a] is the source file of [a] if it exists. *) + val source_file: t -> filename option + + (** [prefix a] is the filename prefix of the compilation artifact. *) + val prefix: t -> file_prefix + + (** [filename u] is the filesystem path for a compilation artifact. *) + val filename: t -> filename + + (** [modname a] is the module name of the compilation artifact.*) + val modname: t -> modname + + (** [from_filename filename] reconstructs the module name + [modname_from_source filename] associated to the artifact [filename]. *) + val from_filename: filename -> t + +end + +(** {1:info_build_artifacts Derived build artifact metadata} *) + +(** Those functions derive a specific [artifact] metadata from an [unit] + metadata.*) +val cmi: t -> Artifact.t +val cmo: t -> Artifact.t +val cmx: t -> Artifact.t +val obj: t -> Artifact.t +val cmt: t -> Artifact.t +val cmti: t -> Artifact.t +val annot: t -> Artifact.t + +(** The functions below change the type of an artifact by updating the + extension of its filename. + Those functions purposefully do not cover all artifact kinds because we want + to track which artifacts are assumed to be bundled together. *) +val companion_obj: Artifact.t -> Artifact.t +val companion_cmt: Artifact.t -> Artifact.t + +val companion_cmi: Artifact.t -> Artifact.t +(** Beware that [companion_cmi a] strips all extensions from the + filename of [a] before adding the [".cmi"] suffix contrarily to + the other functions which only remove the rightmost extension. + In other words, the companion cmi of a file [something.d.cmo] is + [something.cmi] and not [something.d.cmi]. +*) + +(** {1:ml_mli_cmi_interaction Mli and cmi derived from implementation files } *) + +(** The compilation of module implementation changes in presence of mli and cmi + files, the function belows help to handle this. *) + +(** [mli_from_source u] is the interface source filename associated to the unit + [u]. The actual suffix depends on {!Config.interface_suffix}. +*) +val mli_from_source: t -> filename + +(** [mli_from_artifact t] is the name of the interface source file derived from + the artifact [t]. This variant is necessary when handling artifacts derived + from an unknown source files (e.g. packed modules). *) +val mli_from_artifact: Artifact.t -> filename + +(** Check if the artifact is a cmi *) +val is_cmi: Artifact.t -> bool + +(** [find_normalized_cmi u] finds in the load_path a file matching the module + name [modname u]. + @raise Not_found if no such cmi exists *) +val find_normalized_cmi: t -> Artifact.t diff --git a/src/ocaml/preprocess/lexer_raw.mll b/src/ocaml/preprocess/lexer_raw.mll index a28dfb3f04..d80597c833 100644 --- a/src/ocaml/preprocess/lexer_raw.mll +++ b/src/ocaml/preprocess/lexer_raw.mll @@ -149,6 +149,35 @@ let list_keywords = fun keywords -> Hashtbl.fold add_kw keywords init +let store_string_char buf c = Buffer.add_char buf c +let store_substring buf s ~pos ~len = Buffer.add_substring buf s pos len + +let store_normalized_newline buf newline = + (* #12502: we normalize "\r\n" to "\n" at lexing time, + to avoid behavior difference due to OS-specific + newline characters in string literals. + + (For example, Git for Windows will translate \n in versioned + files into \r\n sequences when checking out files on Windows. If + your code contains multiline quoted string literals, the raw + content of the string literal would be different between Git for + Windows users and all other users. Thanks to newline + normalization, the value of the literal as a string constant will + be the same no matter which programming tools are used.) + + Many programming languages use the same approach, for example + Java, Javascript, Kotlin, Python, Swift and C++. + *) + (* Our 'newline' regexp accepts \r*\n, but we only wish + to normalize \r?\n into \n -- see the discussion in #12502. + All carriage returns except for the (optional) last one + are reproduced in the output. We implement this by skipping + the first carriage return, if any. *) + let len = String.length newline in + if len = 1 + then store_string_char buf '\n' + else store_substring buf newline ~pos:1 ~len:(len - 1) + (* To store the position of the beginning of a string and comment *) let in_comment state = state.comment_start_loc <> [] @@ -263,6 +292,7 @@ let keyword_or state s default = with Not_found -> default let is_keyword name = Hashtbl.mem keyword_table name +let () = Lexer.is_keyword_ref := is_keyword let check_label_name lexbuf name = if is_keyword name @@ -283,14 +313,12 @@ let update_loc lexbuf _file line absolute chars = pos_lnum = if absolute then line else pos.pos_lnum + line; pos_bol = pos.pos_cnum - chars; } -;; (* Warn about Latin-1 characters used in idents *) let warn_latin1 lexbuf = Location.deprecated (Location.curr lexbuf) "ISO-Latin1 characters in identifiers" -;; (* Error report *) @@ -327,7 +355,7 @@ let prepare_error loc = function Location.error ~loc ~sub msg | Keyword_as_label kwd -> Location.errorf ~loc - "`%s' is a keyword, it cannot be used as label name" kwd + "%a is a keyword, it cannot be used as label name" Style.inline_code kwd | Invalid_literal s -> Location.errorf ~loc "Invalid literal %s" s (* FIXME: Invalid_directive? *) @@ -388,10 +416,12 @@ let hex_float_literal = ('.' ['0'-'9' 'A'-'F' 'a'-'f' '_']* )? (['p' 'P'] ['+' '-']? ['0'-'9'] ['0'-'9' '_']* )? let literal_modifier = ['G'-'Z' 'g'-'z'] +let raw_ident_escape = "\\#" refill {fun k lexbuf -> Refill (fun () -> k lexbuf)} + rule token state = parse | ("\\" as bs) newline { match state.preprocessor with @@ -422,6 +452,8 @@ rule token state = parse { fail lexbuf (Reserved_sequence (".~", Some "is reserved for use in MetaOCaml")) } *) + | "~" raw_ident_escape (lowercase identchar * as name) ':' + { return (LABEL name) } | "~" (lowercase identchar * as name) ':' { lABEL (check_label_name lexbuf name) } | "~" (lowercase_latin1 identchar_latin1 * as name) ':' @@ -429,10 +461,14 @@ rule token state = parse return (LABEL name) } | "?" { return QUESTION } + | "?" raw_ident_escape (lowercase identchar * as name) ':' + { return (OPTLABEL name) } | "?" (lowercase identchar * as name) ':' { oPTLABEL (check_label_name lexbuf name) } | "?" (lowercase_latin1 identchar_latin1 * as name) ':' { warn_latin1 lexbuf; return (OPTLABEL name) } + | raw_ident_escape (lowercase identchar * as name) + { return (LIDENT name) } | lowercase identchar * as name { return (try Hashtbl.find state.keywords name with Not_found -> @@ -507,7 +543,7 @@ rule token state = parse { char_for_decimal_code state lexbuf 2 >>= fun c -> return (CHAR c) } | "\'\\" 'x' ['0'-'9' 'a'-'f' 'A'-'F'] ['0'-'9' 'a'-'f' 'A'-'F'] "\'" { return (CHAR (char_for_hexadecimal_code lexbuf 3)) } - | "\'" ("\\" _ as esc) + | "\'" ("\\" [^ '#'] as esc) { fail lexbuf (Illegal_escape (esc, None)) } | "(*" { let start_loc = Location.curr lexbuf in @@ -680,22 +716,24 @@ and comment state = parse Buffer.add_char state.buffer '}'; comment state lexbuf } - | "''" + | "\'\'" { Buffer.add_string state.buffer (Lexing.lexeme lexbuf); comment state lexbuf } - | "'" newline "'" + | "\'" (newline as nl) "\'" { update_loc lexbuf None 1 false 1; - Buffer.add_string state.buffer (Lexing.lexeme lexbuf); + store_string_char state.buffer '\''; + store_normalized_newline state.buffer nl; + store_string_char state.buffer '\''; comment state lexbuf } - | "'" [^ '\\' '\'' '\010' '\013' ] "'" + | "\'" [^ '\\' '\'' '\010' '\013' ] "'" { Buffer.add_string state.buffer (Lexing.lexeme lexbuf); comment state lexbuf } - | "'\\" ['\\' '\"' '\'' 'n' 't' 'b' 'r' ' '] "'" + | "\'\\" ['\\' '\"' '\'' 'n' 't' 'b' 'r' ' '] "'" { Buffer.add_string state.buffer (Lexing.lexeme lexbuf); comment state lexbuf } - | "'\\" ['0'-'9'] ['0'-'9'] ['0'-'9'] "'" + | "\'\\" ['0'-'9'] ['0'-'9'] ['0'-'9'] "'" { Buffer.add_string state.buffer (Lexing.lexeme lexbuf); comment state lexbuf } | "\'\\" 'o' ['0'-'3'] ['0'-'7'] ['0'-'7'] "\'" { Buffer.add_string state.buffer (Lexing.lexeme lexbuf); comment state lexbuf } - | "'\\" 'x' ['0'-'9' 'a'-'f' 'A'-'F'] ['0'-'9' 'a'-'f' 'A'-'F'] "'" + | "\'\\" 'x' ['0'-'9' 'a'-'f' 'A'-'F'] ['0'-'9' 'a'-'f' 'A'-'F'] "'" { Buffer.add_string state.buffer (Lexing.lexeme lexbuf); comment state lexbuf } | eof { match state.comment_start_loc with @@ -705,9 +743,9 @@ and comment state = parse state.comment_start_loc <- []; fail_loc (Unterminated_comment start) loc } - | newline + | newline as nl { update_loc lexbuf None 1 false 0; - Buffer.add_string state.buffer (Lexing.lexeme lexbuf); + store_normalized_newline state.buffer nl; comment state lexbuf } | (lowercase | uppercase) identchar * @@ -751,11 +789,9 @@ and string state = parse string state lexbuf end } - | newline - { if not (in_comment state) then - Location.prerr_warning (Location.curr lexbuf) Warnings.Eol_in_string; - update_loc lexbuf None 1 false 0; - Buffer.add_string state.buffer (Lexing.lexeme lexbuf); + | newline as nl + { update_loc lexbuf None 1 false 0; + store_normalized_newline state.buffer nl; string state lexbuf } | eof @@ -767,9 +803,9 @@ and string state = parse string state lexbuf } and quoted_string delim state = parse - | newline + | newline as nl { update_loc lexbuf None 1 false 0; - Buffer.add_string state.buffer (Lexing.lexeme lexbuf); + store_normalized_newline state.buffer nl; quoted_string delim state lexbuf } | eof diff --git a/src/ocaml/preprocess/parser_explain.ml b/src/ocaml/preprocess/parser_explain.ml index ef02f70969..2f5db44a21 100644 --- a/src/ocaml/preprocess/parser_explain.ml +++ b/src/ocaml/preprocess/parser_explain.ml @@ -21,6 +21,7 @@ let nullable (type a) : a MenhirInterpreter.nonterminal -> bool = | N_option_preceded_EQUAL_module_type__ -> true | N_option_preceded_EQUAL_expr__ -> true | N_option_preceded_COLON_core_type__ -> true + | N_option_preceded_COLON_atomic_type__ -> true | N_option_preceded_AS_mkrhs_LIDENT___ -> true | N_option_SEMI_ -> true | N_option_BAR_ -> true @@ -48,4 +49,5 @@ let nullable (type a) : a MenhirInterpreter.nonterminal -> bool = | N_ext -> true | N_class_self_type -> true | N_class_self_pattern -> true + | N_attr_payload -> true | _ -> false diff --git a/src/ocaml/preprocess/parser_printer.ml b/src/ocaml/preprocess/parser_printer.ml index e49be91525..6b7830e814 100644 --- a/src/ocaml/preprocess/parser_printer.ml +++ b/src/ocaml/preprocess/parser_printer.ml @@ -20,7 +20,6 @@ open Parser_raw let print_symbol = function | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_error) -> "error" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_WITH) -> "with" - | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_WHILE_LWT) -> "while_lwt" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_WHILE) -> "while" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_WHEN) -> "when" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_VIRTUAL) -> "virtual" @@ -28,7 +27,6 @@ let print_symbol = function | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_UNDERSCORE) -> "_" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_UIDENT) -> "UIDENT" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_TYPE) -> "type" - | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_TRY_LWT) -> "try_lwt" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_TRY) -> "try" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_TRUE) -> "true" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_TO) -> "to" @@ -67,11 +65,9 @@ let print_symbol = function | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_MINUSDOT) -> "-." | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_MINUS) -> "-" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_METHOD) -> "method" - | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_MATCH_LWT) -> "match_lwt" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_MATCH) -> "match" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_LPAREN) -> ")" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_LIDENT) -> "LIDENT" - | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_LET_LWT) -> "lwt" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_LETOP) -> "LETOP" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_LET) -> "let" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_LESSMINUS) -> "<-" @@ -109,10 +105,8 @@ let print_symbol = function | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_FUNCTOR) -> "functor" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_FUNCTION) -> "function" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_FUN) -> "fun" - | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_FOR_LWT) -> "for_lwt" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_FOR) -> "for" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_FLOAT) -> "FLOAT" - | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_FINALLY_LWT) -> "finally" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_FALSE) -> "false" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_EXTERNAL) -> "external" | MenhirInterpreter.X (MenhirInterpreter.T MenhirInterpreter.T_EXCEPTION) -> "exception" @@ -207,6 +201,7 @@ let print_symbol = function | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_reversed_nonempty_llist_name_tag_) -> "reversed_nonempty_llist_name_tag_" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_reversed_nonempty_llist_labeled_simple_expr_) -> "reversed_nonempty_llist_labeled_simple_expr_" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_reversed_nonempty_llist_functor_arg_) -> "reversed_nonempty_llist_functor_arg_" + | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_reversed_nonempty_concat_fun_param_as_list_) -> "reversed_nonempty_concat_fun_param_as_list_" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_reversed_llist_preceded_CONSTRAINT_constrain__) -> "reversed_llist_preceded_CONSTRAINT_constrain__" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_reversed_bar_llist_extension_constructor_declaration_) -> "reversed_bar_llist_extension_constructor_declaration_" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_reversed_bar_llist_extension_constructor_) -> "reversed_bar_llist_extension_constructor_" @@ -245,6 +240,7 @@ let print_symbol = function | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_option_preceded_EQUAL_module_type__) -> "option_preceded_EQUAL_module_type__" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_option_preceded_EQUAL_expr__) -> "option_preceded_EQUAL_expr__" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_option_preceded_COLON_core_type__) -> "option_preceded_COLON_core_type__" + | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_option_preceded_COLON_atomic_type__) -> "option_preceded_COLON_atomic_type__" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_option_preceded_AS_mkrhs_LIDENT___) -> "option_preceded_AS_mkrhs_LIDENT___" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_option_SEMI_) -> "option_SEMI_" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_option_BAR_) -> "option_BAR_" @@ -252,6 +248,7 @@ let print_symbol = function | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_operator) -> "operator" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_open_description) -> "open_description" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_open_declaration) -> "open_declaration" + | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_object_type) -> "object_type" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_nonempty_type_kind) -> "nonempty_type_kind" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_nonempty_list_raw_string_) -> "nonempty_list_raw_string_" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_nonempty_list_mkrhs_LIDENT__) -> "nonempty_list_mkrhs_LIDENT__" @@ -273,14 +270,12 @@ let print_symbol = function | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_longident_UIDENT_) -> "mk_longident_mod_longident_UIDENT_" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_longident_LIDENT_) -> "mk_longident_mod_longident_LIDENT_" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_ext_longident_ident_) -> "mk_longident_mod_ext_longident_ident_" - | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_ext_longident___anonymous_41_) -> "mk_longident_mod_ext_longident___anonymous_41_" + | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_ext_longident___anonymous_43_) -> "mk_longident_mod_ext_longident___anonymous_43_" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_ext_longident_UIDENT_) -> "mk_longident_mod_ext_longident_UIDENT_" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_ext_longident_LIDENT_) -> "mk_longident_mod_ext_longident_LIDENT_" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_method_) -> "method_" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_meth_list) -> "meth_list" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_match_case) -> "match_case" - | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_lwt_bindings) -> "lwt_bindings" - | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_lwt_binding) -> "lwt_binding" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_listx_SEMI_record_pat_field_UNDERSCORE_) -> "listx_SEMI_record_pat_field_UNDERSCORE_" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_list_use_file_element_) -> "list_use_file_element_" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_list_text_str_structure_item__) -> "list_text_str_structure_item__" @@ -324,16 +319,21 @@ let print_symbol = function | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_functor_args) -> "functor_args" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_functor_arg) -> "functor_arg" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_function_type) -> "function_type" - | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_fun_def) -> "fun_def" - | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_fun_binding) -> "fun_binding" + | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_fun_seq_expr) -> "fun_seq_expr" + | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_fun_params) -> "fun_params" + | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_fun_param_as_list) -> "fun_param_as_list" + | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_fun_expr) -> "fun_expr" + | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_fun_body) -> "fun_body" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_formal_class_parameters) -> "formal_class_parameters" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_floating_attribute) -> "floating_attribute" + | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_extension_type) -> "extension_type" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_extension_constructor_rebind_epsilon_) -> "extension_constructor_rebind_epsilon_" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_extension_constructor_rebind_BAR_) -> "extension_constructor_rebind_BAR_" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_extension) -> "extension" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_ext) -> "ext" - | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_expr) -> "expr" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_direction_flag) -> "direction_flag" + | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_delimited_type_supporting_local_open) -> "delimited_type_supporting_local_open" + | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_delimited_type) -> "delimited_type" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_core_type) -> "core_type" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_constructor_declarations) -> "constructor_declarations" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_constructor_arguments) -> "constructor_arguments" @@ -356,6 +356,7 @@ let print_symbol = function | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_class_field) -> "class_field" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_class_expr) -> "class_expr" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_attribute) -> "attribute" + | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_attr_payload) -> "attr_payload" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_attr_id) -> "attr_id" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_atomic_type) -> "atomic_type" | MenhirInterpreter.X (MenhirInterpreter.N MenhirInterpreter.N_any_longident) -> "any_longident" @@ -366,7 +367,6 @@ let print_symbol = function let print_value (type a) : a MenhirInterpreter.symbol -> a -> string = function | MenhirInterpreter.T MenhirInterpreter.T_error -> (fun _ -> "error") | MenhirInterpreter.T MenhirInterpreter.T_WITH -> (fun _ -> "with") - | MenhirInterpreter.T MenhirInterpreter.T_WHILE_LWT -> (fun _ -> "while_lwt") | MenhirInterpreter.T MenhirInterpreter.T_WHILE -> (fun _ -> "while") | MenhirInterpreter.T MenhirInterpreter.T_WHEN -> (fun _ -> "when") | MenhirInterpreter.T MenhirInterpreter.T_VIRTUAL -> (fun _ -> "virtual") @@ -374,7 +374,6 @@ let print_value (type a) : a MenhirInterpreter.symbol -> a -> string = function | MenhirInterpreter.T MenhirInterpreter.T_UNDERSCORE -> (fun _ -> "_") | MenhirInterpreter.T MenhirInterpreter.T_UIDENT -> (Printf.sprintf "UIDENT(%S)") | MenhirInterpreter.T MenhirInterpreter.T_TYPE -> (fun _ -> "type") - | MenhirInterpreter.T MenhirInterpreter.T_TRY_LWT -> (fun _ -> "try_lwt") | MenhirInterpreter.T MenhirInterpreter.T_TRY -> (fun _ -> "try") | MenhirInterpreter.T MenhirInterpreter.T_TRUE -> (fun _ -> "true") | MenhirInterpreter.T MenhirInterpreter.T_TO -> (fun _ -> "to") @@ -413,11 +412,9 @@ let print_value (type a) : a MenhirInterpreter.symbol -> a -> string = function | MenhirInterpreter.T MenhirInterpreter.T_MINUSDOT -> (fun _ -> "-.") | MenhirInterpreter.T MenhirInterpreter.T_MINUS -> (fun _ -> "-") | MenhirInterpreter.T MenhirInterpreter.T_METHOD -> (fun _ -> "method") - | MenhirInterpreter.T MenhirInterpreter.T_MATCH_LWT -> (fun _ -> "match_lwt") | MenhirInterpreter.T MenhirInterpreter.T_MATCH -> (fun _ -> "match") | MenhirInterpreter.T MenhirInterpreter.T_LPAREN -> (fun _ -> ")") | MenhirInterpreter.T MenhirInterpreter.T_LIDENT -> (Printf.sprintf "LIDENT(%S)") - | MenhirInterpreter.T MenhirInterpreter.T_LET_LWT -> (fun _ -> "lwt") | MenhirInterpreter.T MenhirInterpreter.T_LETOP -> (fun _ -> "LETOP") | MenhirInterpreter.T MenhirInterpreter.T_LET -> (fun _ -> "let") | MenhirInterpreter.T MenhirInterpreter.T_LESSMINUS -> (fun _ -> "<-") @@ -455,10 +452,8 @@ let print_value (type a) : a MenhirInterpreter.symbol -> a -> string = function | MenhirInterpreter.T MenhirInterpreter.T_FUNCTOR -> (fun _ -> "functor") | MenhirInterpreter.T MenhirInterpreter.T_FUNCTION -> (fun _ -> "function") | MenhirInterpreter.T MenhirInterpreter.T_FUN -> (fun _ -> "fun") - | MenhirInterpreter.T MenhirInterpreter.T_FOR_LWT -> (fun _ -> "for_lwt") | MenhirInterpreter.T MenhirInterpreter.T_FOR -> (fun _ -> "for") | MenhirInterpreter.T MenhirInterpreter.T_FLOAT -> (string_of_FLOAT) - | MenhirInterpreter.T MenhirInterpreter.T_FINALLY_LWT -> (fun _ -> "finally") | MenhirInterpreter.T MenhirInterpreter.T_FALSE -> (fun _ -> "false") | MenhirInterpreter.T MenhirInterpreter.T_EXTERNAL -> (fun _ -> "external") | MenhirInterpreter.T MenhirInterpreter.T_EXCEPTION -> (fun _ -> "exception") @@ -553,6 +548,7 @@ let print_value (type a) : a MenhirInterpreter.symbol -> a -> string = function | MenhirInterpreter.N MenhirInterpreter.N_reversed_nonempty_llist_name_tag_ -> (fun _ -> "reversed_nonempty_llist_name_tag_") | MenhirInterpreter.N MenhirInterpreter.N_reversed_nonempty_llist_labeled_simple_expr_ -> (fun _ -> "reversed_nonempty_llist_labeled_simple_expr_") | MenhirInterpreter.N MenhirInterpreter.N_reversed_nonempty_llist_functor_arg_ -> (fun _ -> "reversed_nonempty_llist_functor_arg_") + | MenhirInterpreter.N MenhirInterpreter.N_reversed_nonempty_concat_fun_param_as_list_ -> (fun _ -> "reversed_nonempty_concat_fun_param_as_list_") | MenhirInterpreter.N MenhirInterpreter.N_reversed_llist_preceded_CONSTRAINT_constrain__ -> (fun _ -> "reversed_llist_preceded_CONSTRAINT_constrain__") | MenhirInterpreter.N MenhirInterpreter.N_reversed_bar_llist_extension_constructor_declaration_ -> (fun _ -> "reversed_bar_llist_extension_constructor_declaration_") | MenhirInterpreter.N MenhirInterpreter.N_reversed_bar_llist_extension_constructor_ -> (fun _ -> "reversed_bar_llist_extension_constructor_") @@ -591,6 +587,7 @@ let print_value (type a) : a MenhirInterpreter.symbol -> a -> string = function | MenhirInterpreter.N MenhirInterpreter.N_option_preceded_EQUAL_module_type__ -> (fun _ -> "option_preceded_EQUAL_module_type__") | MenhirInterpreter.N MenhirInterpreter.N_option_preceded_EQUAL_expr__ -> (fun _ -> "option_preceded_EQUAL_expr__") | MenhirInterpreter.N MenhirInterpreter.N_option_preceded_COLON_core_type__ -> (fun _ -> "option_preceded_COLON_core_type__") + | MenhirInterpreter.N MenhirInterpreter.N_option_preceded_COLON_atomic_type__ -> (fun _ -> "option_preceded_COLON_atomic_type__") | MenhirInterpreter.N MenhirInterpreter.N_option_preceded_AS_mkrhs_LIDENT___ -> (fun _ -> "option_preceded_AS_mkrhs_LIDENT___") | MenhirInterpreter.N MenhirInterpreter.N_option_SEMI_ -> (fun _ -> "option_SEMI_") | MenhirInterpreter.N MenhirInterpreter.N_option_BAR_ -> (fun _ -> "option_BAR_") @@ -598,6 +595,7 @@ let print_value (type a) : a MenhirInterpreter.symbol -> a -> string = function | MenhirInterpreter.N MenhirInterpreter.N_operator -> (fun _ -> "operator") | MenhirInterpreter.N MenhirInterpreter.N_open_description -> (fun _ -> "open_description") | MenhirInterpreter.N MenhirInterpreter.N_open_declaration -> (fun _ -> "open_declaration") + | MenhirInterpreter.N MenhirInterpreter.N_object_type -> (fun _ -> "object_type") | MenhirInterpreter.N MenhirInterpreter.N_nonempty_type_kind -> (fun _ -> "nonempty_type_kind") | MenhirInterpreter.N MenhirInterpreter.N_nonempty_list_raw_string_ -> (fun _ -> "nonempty_list_raw_string_") | MenhirInterpreter.N MenhirInterpreter.N_nonempty_list_mkrhs_LIDENT__ -> (fun _ -> "nonempty_list_mkrhs_LIDENT__") @@ -619,14 +617,12 @@ let print_value (type a) : a MenhirInterpreter.symbol -> a -> string = function | MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_longident_UIDENT_ -> (fun _ -> "mk_longident_mod_longident_UIDENT_") | MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_longident_LIDENT_ -> (fun _ -> "mk_longident_mod_longident_LIDENT_") | MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_ext_longident_ident_ -> (fun _ -> "mk_longident_mod_ext_longident_ident_") - | MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_ext_longident___anonymous_41_ -> (fun _ -> "mk_longident_mod_ext_longident___anonymous_41_") + | MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_ext_longident___anonymous_43_ -> (fun _ -> "mk_longident_mod_ext_longident___anonymous_43_") | MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_ext_longident_UIDENT_ -> (fun _ -> "mk_longident_mod_ext_longident_UIDENT_") | MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_ext_longident_LIDENT_ -> (fun _ -> "mk_longident_mod_ext_longident_LIDENT_") | MenhirInterpreter.N MenhirInterpreter.N_method_ -> (fun _ -> "method_") | MenhirInterpreter.N MenhirInterpreter.N_meth_list -> (fun _ -> "meth_list") | MenhirInterpreter.N MenhirInterpreter.N_match_case -> (fun _ -> "match_case") - | MenhirInterpreter.N MenhirInterpreter.N_lwt_bindings -> (fun _ -> "lwt_bindings") - | MenhirInterpreter.N MenhirInterpreter.N_lwt_binding -> (fun _ -> "lwt_binding") | MenhirInterpreter.N MenhirInterpreter.N_listx_SEMI_record_pat_field_UNDERSCORE_ -> (fun _ -> "listx_SEMI_record_pat_field_UNDERSCORE_") | MenhirInterpreter.N MenhirInterpreter.N_list_use_file_element_ -> (fun _ -> "list_use_file_element_") | MenhirInterpreter.N MenhirInterpreter.N_list_text_str_structure_item__ -> (fun _ -> "list_text_str_structure_item__") @@ -670,16 +666,21 @@ let print_value (type a) : a MenhirInterpreter.symbol -> a -> string = function | MenhirInterpreter.N MenhirInterpreter.N_functor_args -> (fun _ -> "functor_args") | MenhirInterpreter.N MenhirInterpreter.N_functor_arg -> (fun _ -> "functor_arg") | MenhirInterpreter.N MenhirInterpreter.N_function_type -> (fun _ -> "function_type") - | MenhirInterpreter.N MenhirInterpreter.N_fun_def -> (fun _ -> "fun_def") - | MenhirInterpreter.N MenhirInterpreter.N_fun_binding -> (fun _ -> "fun_binding") + | MenhirInterpreter.N MenhirInterpreter.N_fun_seq_expr -> (fun _ -> "fun_seq_expr") + | MenhirInterpreter.N MenhirInterpreter.N_fun_params -> (fun _ -> "fun_params") + | MenhirInterpreter.N MenhirInterpreter.N_fun_param_as_list -> (fun _ -> "fun_param_as_list") + | MenhirInterpreter.N MenhirInterpreter.N_fun_expr -> (fun _ -> "fun_expr") + | MenhirInterpreter.N MenhirInterpreter.N_fun_body -> (fun _ -> "fun_body") | MenhirInterpreter.N MenhirInterpreter.N_formal_class_parameters -> (fun _ -> "formal_class_parameters") | MenhirInterpreter.N MenhirInterpreter.N_floating_attribute -> (fun _ -> "floating_attribute") + | MenhirInterpreter.N MenhirInterpreter.N_extension_type -> (fun _ -> "extension_type") | MenhirInterpreter.N MenhirInterpreter.N_extension_constructor_rebind_epsilon_ -> (fun _ -> "extension_constructor_rebind_epsilon_") | MenhirInterpreter.N MenhirInterpreter.N_extension_constructor_rebind_BAR_ -> (fun _ -> "extension_constructor_rebind_BAR_") | MenhirInterpreter.N MenhirInterpreter.N_extension -> (fun _ -> "extension") | MenhirInterpreter.N MenhirInterpreter.N_ext -> (fun _ -> "ext") - | MenhirInterpreter.N MenhirInterpreter.N_expr -> (fun _ -> "expr") | MenhirInterpreter.N MenhirInterpreter.N_direction_flag -> (fun _ -> "direction_flag") + | MenhirInterpreter.N MenhirInterpreter.N_delimited_type_supporting_local_open -> (fun _ -> "delimited_type_supporting_local_open") + | MenhirInterpreter.N MenhirInterpreter.N_delimited_type -> (fun _ -> "delimited_type") | MenhirInterpreter.N MenhirInterpreter.N_core_type -> (fun _ -> "core_type") | MenhirInterpreter.N MenhirInterpreter.N_constructor_declarations -> (fun _ -> "constructor_declarations") | MenhirInterpreter.N MenhirInterpreter.N_constructor_arguments -> (fun _ -> "constructor_arguments") @@ -702,6 +703,7 @@ let print_value (type a) : a MenhirInterpreter.symbol -> a -> string = function | MenhirInterpreter.N MenhirInterpreter.N_class_field -> (fun _ -> "class_field") | MenhirInterpreter.N MenhirInterpreter.N_class_expr -> (fun _ -> "class_expr") | MenhirInterpreter.N MenhirInterpreter.N_attribute -> (fun _ -> "attribute") + | MenhirInterpreter.N MenhirInterpreter.N_attr_payload -> (fun _ -> "attr_payload") | MenhirInterpreter.N MenhirInterpreter.N_attr_id -> (fun _ -> "attr_id") | MenhirInterpreter.N MenhirInterpreter.N_atomic_type -> (fun _ -> "atomic_type") | MenhirInterpreter.N MenhirInterpreter.N_any_longident -> (fun _ -> "any_longident") @@ -711,7 +713,6 @@ let print_value (type a) : a MenhirInterpreter.symbol -> a -> string = function let print_token = function | WITH -> print_value (MenhirInterpreter.T MenhirInterpreter.T_WITH) () - | WHILE_LWT -> print_value (MenhirInterpreter.T MenhirInterpreter.T_WHILE_LWT) () | WHILE -> print_value (MenhirInterpreter.T MenhirInterpreter.T_WHILE) () | WHEN -> print_value (MenhirInterpreter.T MenhirInterpreter.T_WHEN) () | VIRTUAL -> print_value (MenhirInterpreter.T MenhirInterpreter.T_VIRTUAL) () @@ -719,7 +720,6 @@ let print_token = function | UNDERSCORE -> print_value (MenhirInterpreter.T MenhirInterpreter.T_UNDERSCORE) () | UIDENT v -> print_value (MenhirInterpreter.T MenhirInterpreter.T_UIDENT) v | TYPE -> print_value (MenhirInterpreter.T MenhirInterpreter.T_TYPE) () - | TRY_LWT -> print_value (MenhirInterpreter.T MenhirInterpreter.T_TRY_LWT) () | TRY -> print_value (MenhirInterpreter.T MenhirInterpreter.T_TRY) () | TRUE -> print_value (MenhirInterpreter.T MenhirInterpreter.T_TRUE) () | TO -> print_value (MenhirInterpreter.T MenhirInterpreter.T_TO) () @@ -758,11 +758,9 @@ let print_token = function | MINUSDOT -> print_value (MenhirInterpreter.T MenhirInterpreter.T_MINUSDOT) () | MINUS -> print_value (MenhirInterpreter.T MenhirInterpreter.T_MINUS) () | METHOD -> print_value (MenhirInterpreter.T MenhirInterpreter.T_METHOD) () - | MATCH_LWT -> print_value (MenhirInterpreter.T MenhirInterpreter.T_MATCH_LWT) () | MATCH -> print_value (MenhirInterpreter.T MenhirInterpreter.T_MATCH) () | LPAREN -> print_value (MenhirInterpreter.T MenhirInterpreter.T_LPAREN) () | LIDENT v -> print_value (MenhirInterpreter.T MenhirInterpreter.T_LIDENT) v - | LET_LWT -> print_value (MenhirInterpreter.T MenhirInterpreter.T_LET_LWT) () | LETOP v -> print_value (MenhirInterpreter.T MenhirInterpreter.T_LETOP) v | LET -> print_value (MenhirInterpreter.T MenhirInterpreter.T_LET) () | LESSMINUS -> print_value (MenhirInterpreter.T MenhirInterpreter.T_LESSMINUS) () @@ -800,10 +798,8 @@ let print_token = function | FUNCTOR -> print_value (MenhirInterpreter.T MenhirInterpreter.T_FUNCTOR) () | FUNCTION -> print_value (MenhirInterpreter.T MenhirInterpreter.T_FUNCTION) () | FUN -> print_value (MenhirInterpreter.T MenhirInterpreter.T_FUN) () - | FOR_LWT -> print_value (MenhirInterpreter.T MenhirInterpreter.T_FOR_LWT) () | FOR -> print_value (MenhirInterpreter.T MenhirInterpreter.T_FOR) () | FLOAT v -> print_value (MenhirInterpreter.T MenhirInterpreter.T_FLOAT) v - | FINALLY_LWT -> print_value (MenhirInterpreter.T MenhirInterpreter.T_FINALLY_LWT) () | FALSE -> print_value (MenhirInterpreter.T MenhirInterpreter.T_FALSE) () | EXTERNAL -> print_value (MenhirInterpreter.T MenhirInterpreter.T_EXTERNAL) () | EXCEPTION -> print_value (MenhirInterpreter.T MenhirInterpreter.T_EXCEPTION) () @@ -847,7 +843,6 @@ let token_of_terminal (type a) (t : a MenhirInterpreter.terminal) (v : a) : toke match t with | MenhirInterpreter.T_error -> assert false | MenhirInterpreter.T_WITH -> WITH - | MenhirInterpreter.T_WHILE_LWT -> WHILE_LWT | MenhirInterpreter.T_WHILE -> WHILE | MenhirInterpreter.T_WHEN -> WHEN | MenhirInterpreter.T_VIRTUAL -> VIRTUAL @@ -855,7 +850,6 @@ let token_of_terminal (type a) (t : a MenhirInterpreter.terminal) (v : a) : toke | MenhirInterpreter.T_UNDERSCORE -> UNDERSCORE | MenhirInterpreter.T_UIDENT -> UIDENT v | MenhirInterpreter.T_TYPE -> TYPE - | MenhirInterpreter.T_TRY_LWT -> TRY_LWT | MenhirInterpreter.T_TRY -> TRY | MenhirInterpreter.T_TRUE -> TRUE | MenhirInterpreter.T_TO -> TO @@ -894,11 +888,9 @@ let token_of_terminal (type a) (t : a MenhirInterpreter.terminal) (v : a) : toke | MenhirInterpreter.T_MINUSDOT -> MINUSDOT | MenhirInterpreter.T_MINUS -> MINUS | MenhirInterpreter.T_METHOD -> METHOD - | MenhirInterpreter.T_MATCH_LWT -> MATCH_LWT | MenhirInterpreter.T_MATCH -> MATCH | MenhirInterpreter.T_LPAREN -> LPAREN | MenhirInterpreter.T_LIDENT -> LIDENT v - | MenhirInterpreter.T_LET_LWT -> LET_LWT | MenhirInterpreter.T_LETOP -> LETOP v | MenhirInterpreter.T_LET -> LET | MenhirInterpreter.T_LESSMINUS -> LESSMINUS @@ -936,10 +928,8 @@ let token_of_terminal (type a) (t : a MenhirInterpreter.terminal) (v : a) : toke | MenhirInterpreter.T_FUNCTOR -> FUNCTOR | MenhirInterpreter.T_FUNCTION -> FUNCTION | MenhirInterpreter.T_FUN -> FUN - | MenhirInterpreter.T_FOR_LWT -> FOR_LWT | MenhirInterpreter.T_FOR -> FOR | MenhirInterpreter.T_FLOAT -> FLOAT v - | MenhirInterpreter.T_FINALLY_LWT -> FINALLY_LWT | MenhirInterpreter.T_FALSE -> FALSE | MenhirInterpreter.T_EXTERNAL -> EXTERNAL | MenhirInterpreter.T_EXCEPTION -> EXCEPTION diff --git a/src/ocaml/preprocess/parser_raw.ml b/src/ocaml/preprocess/parser_raw.ml index ee80fe7647..190b5b4887 100644 --- a/src/ocaml/preprocess/parser_raw.ml +++ b/src/ocaml/preprocess/parser_raw.ml @@ -10,19 +10,17 @@ module MenhirBasics = struct type token = | WITH - | WHILE_LWT | WHILE | WHEN | VIRTUAL | VAL | UNDERSCORE | UIDENT of ( -# 845 "src/ocaml/preprocess/parser_raw.mly" +# 890 "src/ocaml/preprocess/parser_raw.mly" (string) -# 23 "src/ocaml/preprocess/parser_raw.ml" +# 22 "src/ocaml/preprocess/parser_raw.ml" ) | TYPE - | TRY_LWT | TRY | TRUE | TO @@ -30,9 +28,9 @@ module MenhirBasics = struct | THEN | STRUCT | STRING of ( -# 831 "src/ocaml/preprocess/parser_raw.mly" +# 876 "src/ocaml/preprocess/parser_raw.mly" (string * Location.t * string option) -# 36 "src/ocaml/preprocess/parser_raw.ml" +# 34 "src/ocaml/preprocess/parser_raw.ml" ) | STAR | SIG @@ -43,22 +41,22 @@ module MenhirBasics = struct | RBRACKET | RBRACE | QUOTED_STRING_ITEM of ( -# 836 "src/ocaml/preprocess/parser_raw.mly" +# 881 "src/ocaml/preprocess/parser_raw.mly" (string * Location.t * string * Location.t * string option) -# 49 "src/ocaml/preprocess/parser_raw.ml" +# 47 "src/ocaml/preprocess/parser_raw.ml" ) | QUOTED_STRING_EXPR of ( -# 833 "src/ocaml/preprocess/parser_raw.mly" +# 878 "src/ocaml/preprocess/parser_raw.mly" (string * Location.t * string * Location.t * string option) -# 54 "src/ocaml/preprocess/parser_raw.ml" +# 52 "src/ocaml/preprocess/parser_raw.ml" ) | QUOTE | QUESTION | PRIVATE | PREFIXOP of ( -# 817 "src/ocaml/preprocess/parser_raw.mly" +# 862 "src/ocaml/preprocess/parser_raw.mly" (string) -# 62 "src/ocaml/preprocess/parser_raw.ml" +# 60 "src/ocaml/preprocess/parser_raw.ml" ) | PLUSEQ | PLUSDOT @@ -66,9 +64,9 @@ module MenhirBasics = struct | PERCENT | OR | OPTLABEL of ( -# 810 "src/ocaml/preprocess/parser_raw.mly" +# 855 "src/ocaml/preprocess/parser_raw.mly" (string) -# 72 "src/ocaml/preprocess/parser_raw.ml" +# 70 "src/ocaml/preprocess/parser_raw.ml" ) | OPEN | OF @@ -81,19 +79,17 @@ module MenhirBasics = struct | MINUSDOT | MINUS | METHOD - | MATCH_LWT | MATCH | LPAREN | LIDENT of ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 91 "src/ocaml/preprocess/parser_raw.ml" +# 88 "src/ocaml/preprocess/parser_raw.ml" ) - | LET_LWT | LETOP of ( -# 775 "src/ocaml/preprocess/parser_raw.mly" +# 820 "src/ocaml/preprocess/parser_raw.mly" (string) -# 97 "src/ocaml/preprocess/parser_raw.ml" +# 93 "src/ocaml/preprocess/parser_raw.ml" ) | LET | LESSMINUS @@ -111,49 +107,49 @@ module MenhirBasics = struct | LBRACE | LAZY | LABEL of ( -# 780 "src/ocaml/preprocess/parser_raw.mly" +# 825 "src/ocaml/preprocess/parser_raw.mly" (string) -# 117 "src/ocaml/preprocess/parser_raw.ml" +# 113 "src/ocaml/preprocess/parser_raw.ml" ) | INT of ( -# 779 "src/ocaml/preprocess/parser_raw.mly" +# 824 "src/ocaml/preprocess/parser_raw.mly" (string * char option) -# 122 "src/ocaml/preprocess/parser_raw.ml" +# 118 "src/ocaml/preprocess/parser_raw.ml" ) | INITIALIZER | INHERIT | INFIXOP4 of ( -# 773 "src/ocaml/preprocess/parser_raw.mly" +# 818 "src/ocaml/preprocess/parser_raw.mly" (string) -# 129 "src/ocaml/preprocess/parser_raw.ml" +# 125 "src/ocaml/preprocess/parser_raw.ml" ) | INFIXOP3 of ( -# 772 "src/ocaml/preprocess/parser_raw.mly" +# 817 "src/ocaml/preprocess/parser_raw.mly" (string) -# 134 "src/ocaml/preprocess/parser_raw.ml" +# 130 "src/ocaml/preprocess/parser_raw.ml" ) | INFIXOP2 of ( -# 771 "src/ocaml/preprocess/parser_raw.mly" +# 816 "src/ocaml/preprocess/parser_raw.mly" (string) -# 139 "src/ocaml/preprocess/parser_raw.ml" +# 135 "src/ocaml/preprocess/parser_raw.ml" ) | INFIXOP1 of ( -# 770 "src/ocaml/preprocess/parser_raw.mly" +# 815 "src/ocaml/preprocess/parser_raw.mly" (string) -# 144 "src/ocaml/preprocess/parser_raw.ml" +# 140 "src/ocaml/preprocess/parser_raw.ml" ) | INFIXOP0 of ( -# 769 "src/ocaml/preprocess/parser_raw.mly" +# 814 "src/ocaml/preprocess/parser_raw.mly" (string) -# 149 "src/ocaml/preprocess/parser_raw.ml" +# 145 "src/ocaml/preprocess/parser_raw.ml" ) | INCLUDE | IN | IF | HASHOP of ( -# 828 "src/ocaml/preprocess/parser_raw.mly" +# 873 "src/ocaml/preprocess/parser_raw.mly" (string) -# 157 "src/ocaml/preprocess/parser_raw.ml" +# 153 "src/ocaml/preprocess/parser_raw.ml" ) | HASH | GREATERRBRACKET @@ -163,14 +159,12 @@ module MenhirBasics = struct | FUNCTOR | FUNCTION | FUN - | FOR_LWT | FOR | FLOAT of ( -# 758 "src/ocaml/preprocess/parser_raw.mly" +# 803 "src/ocaml/preprocess/parser_raw.mly" (string * char option) -# 172 "src/ocaml/preprocess/parser_raw.ml" +# 167 "src/ocaml/preprocess/parser_raw.ml" ) - | FINALLY_LWT | FALSE | EXTERNAL | EXCEPTION @@ -182,25 +176,25 @@ module MenhirBasics = struct | DOWNTO | DOTTILDE | DOTOP of ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 188 "src/ocaml/preprocess/parser_raw.ml" +# 182 "src/ocaml/preprocess/parser_raw.ml" ) | DOTLESS | DOTDOT | DOT | DONE | DOCSTRING of ( -# 853 "src/ocaml/preprocess/parser_raw.mly" +# 898 "src/ocaml/preprocess/parser_raw.mly" (Docstrings.docstring) -# 197 "src/ocaml/preprocess/parser_raw.ml" +# 191 "src/ocaml/preprocess/parser_raw.ml" ) | DO | CONSTRAINT | COMMENT of ( -# 852 "src/ocaml/preprocess/parser_raw.mly" +# 897 "src/ocaml/preprocess/parser_raw.mly" (string * Location.t) -# 204 "src/ocaml/preprocess/parser_raw.ml" +# 198 "src/ocaml/preprocess/parser_raw.ml" ) | COMMA | COLONGREATER @@ -209,9 +203,9 @@ module MenhirBasics = struct | COLON | CLASS | CHAR of ( -# 738 "src/ocaml/preprocess/parser_raw.mly" +# 783 "src/ocaml/preprocess/parser_raw.mly" (char) -# 215 "src/ocaml/preprocess/parser_raw.ml" +# 209 "src/ocaml/preprocess/parser_raw.ml" ) | BEGIN | BARRBRACKET @@ -222,9 +216,9 @@ module MenhirBasics = struct | ASSERT | AS | ANDOP of ( -# 776 "src/ocaml/preprocess/parser_raw.mly" +# 821 "src/ocaml/preprocess/parser_raw.mly" (string) -# 228 "src/ocaml/preprocess/parser_raw.ml" +# 222 "src/ocaml/preprocess/parser_raw.ml" ) | AND | AMPERSAND @@ -242,6 +236,9 @@ let _eRR = [@@@ocaml.warning "-9"] +[@@@ocaml.warning "-60"] module Str = Ast_helper.Str (* For ocamldep *) +[@@@ocaml.warning "+60"] + open Asttypes open Longident open Parsetree @@ -317,13 +314,13 @@ let push_loc x acc = let reloc_pat ~loc x = { x with ppat_loc = make_loc loc; - ppat_loc_stack = push_loc x.ppat_loc x.ppat_loc_stack };; + ppat_loc_stack = push_loc x.ppat_loc x.ppat_loc_stack } let reloc_exp ~loc x = { x with pexp_loc = make_loc loc; - pexp_loc_stack = push_loc x.pexp_loc x.pexp_loc_stack };; + pexp_loc_stack = push_loc x.pexp_loc x.pexp_loc_stack } let reloc_typ ~loc x = { x with ptyp_loc = make_loc loc; - ptyp_loc_stack = push_loc x.ptyp_loc x.ptyp_loc_stack };; + ptyp_loc_stack = push_loc x.ptyp_loc x.ptyp_loc_stack } let mkexpvar ~loc (name : string) = mkexp ~loc (Pexp_ident(mkrhs (Lident name) loc)) @@ -383,6 +380,10 @@ let mkuplus ~oploc name arg = | _ -> Pexp_apply(mkoperator ~loc:oploc ("~" ^ name), [Nolabel, arg]) +let mk_attr ~loc name payload = + Builtin_attributes.(register_attr Parser name); + Attr.mk ~loc name payload + (* TODO define an abstraction boundary between locations-as-pairs and locations-as-Location.t; it should be clear when we move from one world to the other *) @@ -425,11 +426,13 @@ let rec mktailpat nilloc = let open Location in function let mkstrexp e attrs = { pstr_desc = Pstr_eval (e, attrs); pstr_loc = e.pexp_loc } -let mkexp_constraint ~loc e (t1, t2) = - match t1, t2 with - | Some t, None -> mkexp ~loc (Pexp_constraint(e, t)) - | _, Some t -> mkexp ~loc (Pexp_coerce(e, t1, t)) - | None, None -> assert false +let mkexp_desc_constraint e t = + match t with + | Pconstraint t -> Pexp_constraint(e, t) + | Pcoerce(t1, t2) -> Pexp_coerce(e, t1, t2) + +let mkexp_constraint ~loc e t = + mkexp ~loc (mkexp_desc_constraint e t) let mkexp_opt_constraint ~loc e = function | None -> e @@ -443,6 +446,8 @@ let mkpat_opt_constraint ~loc p = function (*let syntax_error () = raise Syntaxerr.Escape_error*) +let removed_string_set loc = + raise_error Syntaxerr.(Error(Syntaxerr.Removed_string_set(make_loc loc))) (* Using the function [not_expecting] in a semantic action means that this syntactic form is recognized by the parser but is in fact incorrect. This @@ -528,7 +533,9 @@ let builtin_arraylike_name loc _ ~assign paren_kind n = let opname = if !Clflags.fast then "unsafe_" ^ opname else opname in let prefix = match paren_kind with | Paren -> Lident "Array" - | Bracket -> Lident "String" + | Bracket -> + if assign then removed_string_set loc; + Lident "String" | Brace -> let submodule_name = match n with | One -> "Array1" @@ -724,10 +731,11 @@ let extra_rhs_core_type ct ~pos = let docs = rhs_info pos in { ct with ptyp_attributes = add_info_attrs docs ct.ptyp_attributes } -(* +(* moved to ast_helper type let_binding = { lb_pattern: pattern; lb_expression: expression; + lb_constraint: value_constraint option; lb_is_pun: bool; lb_attributes: attributes; lb_docs: docs Lazy.t; @@ -740,10 +748,11 @@ type let_bindings = lbs_extension: string Asttypes.loc option } *) -let mklb first ~loc (p, e, is_pun) attrs = +let mklb first ~loc (p, e, typ, is_pun) attrs = { lb_pattern = p; lb_expression = e; + lb_constraint=typ; lb_is_pun = is_pun; lb_attributes = attrs; lb_docs = symbol_docs_lazy loc; @@ -776,7 +785,7 @@ let val_of_let_bindings ~loc lbs = Vb.mk ~loc:lb.lb_loc ~attrs:lb.lb_attributes ~docs:(Lazy.force lb.lb_docs) ~text:(Lazy.force lb.lb_text) - lb.lb_pattern lb.lb_expression) + ?value_constraint:lb.lb_constraint lb.lb_pattern lb.lb_expression) lbs.lbs_bindings in let str = mkstr ~loc (Pstr_value(lbs.lbs_rec, List.rev bindings)) in @@ -789,7 +798,7 @@ let expr_of_let_bindings ~loc lbs body = List.map (fun lb -> Vb.mk ~loc:lb.lb_loc ~attrs:lb.lb_attributes - lb.lb_pattern lb.lb_expression) + ?value_constraint:lb.lb_constraint lb.lb_pattern lb.lb_expression) lbs.lbs_bindings in mkexp_attrs ~loc (Pexp_let(lbs.lbs_rec, List.rev bindings, body)) @@ -800,13 +809,71 @@ let class_of_let_bindings ~loc lbs body = List.map (fun lb -> Vb.mk ~loc:lb.lb_loc ~attrs:lb.lb_attributes - lb.lb_pattern lb.lb_expression) + ?value_constraint:lb.lb_constraint lb.lb_pattern lb.lb_expression) lbs.lbs_bindings in (* Our use of let_bindings(no_ext) guarantees the following: *) assert (lbs.lbs_extension = None); mkclass ~loc (Pcl_let (lbs.lbs_rec, List.rev bindings, body)) +(* If all the parameters are [Pparam_newtype x], then return [Some xs] where + [xs] is the corresponding list of values [x]. This function is optimized for + the common case, where a list of parameters contains at least one value + parameter. +*) +let all_params_as_newtypes = + let is_newtype { pparam_desc; _ } = + match pparam_desc with + | Pparam_newtype _ -> true + | Pparam_val _ -> false + in + let as_newtype { pparam_desc; pparam_loc } = + match pparam_desc with + | Pparam_newtype x -> Some (x, pparam_loc) + | Pparam_val _ -> None + in + fun params -> + if List.for_all is_newtype params + then Some (List.filter_map as_newtype params) + else None + +(* Given a construct [fun (type a b c) : t -> e], we construct + [Pexp_newtype(a, Pexp_newtype(b, Pexp_newtype(c, Pexp_constraint(e, t))))] + rather than a [Pexp_function]. +*) +let mkghost_newtype_function_body newtypes body_constraint body = + let wrapped_body = + match body_constraint with + | None -> body + | Some body_constraint -> + let loc = { body.pexp_loc with loc_ghost = true } in + Exp.mk (mkexp_desc_constraint body body_constraint) ~loc + in + let expr = + List.fold_right + (fun (newtype, newtype_loc) e -> + (* Mints a ghost location that approximates the newtype's "extent" as + being from the start of the newtype param until the end of the + function body. + *) + let loc = (newtype_loc.Location.loc_start, body.pexp_loc.loc_end) in + ghexp (Pexp_newtype (newtype, e)) ~loc) + newtypes + wrapped_body + in + expr.pexp_desc + +let mkfunction params body_constraint body = + match body with + | Pfunction_cases _ -> Pexp_function (params, body_constraint, body) + | Pfunction_body body_exp -> + (* If all the params are newtypes, then we don't create a function node; + we create nested newtype nodes. *) + match all_params_as_newtypes params with + | None -> Pexp_function (params, body_constraint, body) + | Some newtypes -> + mkghost_newtype_function_body newtypes body_constraint body_exp + (* Alternatively, we could keep the generic module type in the Parsetree and extract the package type during type-checking. In that case, the assertions below should be turned into explicit checks. *) @@ -818,11 +885,11 @@ let package_type_of_module_type pmty = | Pwith_type (lid, ptyp) -> let loc = ptyp.ptype_loc in if ptyp.ptype_params <> [] then - err loc "parametrized types are not supported"; + err loc Syntaxerr.Parameterized_types; if ptyp.ptype_cstrs <> [] then - err loc "constrained types are not supported"; + err loc Syntaxerr.Constrained_types; if ptyp.ptype_private <> Public then - err loc "private types are not supported"; + err loc Syntaxerr.Private_types; (* restrictions below are checked by the 'with_constraint' rule *) (* assert (ptyp.ptype_kind = Ptype_abstract); *) @@ -832,7 +899,7 @@ let package_type_of_module_type pmty = | None -> None end | _ -> - err pmty.pmty_loc "only 'with type t =' constraints are supported"; + err pmty.pmty_loc Not_with_type; None in match pmty with @@ -840,8 +907,7 @@ let package_type_of_module_type pmty = | {pmty_desc = Pmty_with({pmty_desc = Pmty_ident lid}, cstrs)} -> (lid, List.filter_map map_cstr cstrs, pmty.pmty_attributes) | _ -> - err pmty.pmty_loc - "only module type identifier and 'with type' constraints are supported" + err pmty.pmty_loc Neither_identifier_nor_with_type ; (Location.mkloc (Lident "_") pmty.pmty_loc, [], []) let mk_directive_arg ~loc k = @@ -866,35 +932,8 @@ let merloc startpos ?endpos x = let attr = { attr_name = str; attr_loc = loc; attr_payload = PStr [] } in { x with pexp_attributes = attr :: x.pexp_attributes } -let val_of_lwt_bindings ~loc lbs = - let bindings = - List.map - (fun lb -> - Vb.mk ~loc:lb.lb_loc ~attrs:lb.lb_attributes - ~docs:(Lazy.force lb.lb_docs) - ~text:(Lazy.force lb.lb_text) - lb.lb_pattern (Fake.app Fake.Lwt.un_lwt lb.lb_expression)) - lbs.lbs_bindings - in - let str = mkstr ~loc (Pstr_value(lbs.lbs_rec, List.rev bindings)) in - match lbs.lbs_extension with - | None -> str - | Some id -> ghstr ~loc (Pstr_extension((id, PStr [str]), [])) - -let expr_of_lwt_bindings ~loc lbs body = - let bindings = - List.map - (fun lb -> - Vb.mk ~loc:lb.lb_loc ~attrs:lb.lb_attributes - lb.lb_pattern (Fake.app Fake.Lwt.un_lwt lb.lb_expression)) - lbs.lbs_bindings - in - Fake.app Fake.Lwt.in_lwt - (mkexp_attrs ~loc (Pexp_let(lbs.lbs_rec, List.rev bindings, body)) - (lbs.lbs_extension, [])) - -# 898 "src/ocaml/preprocess/parser_raw.ml" +# 937 "src/ocaml/preprocess/parser_raw.ml" module Tables = struct @@ -904,266 +943,254 @@ module Tables = struct fun _tok -> match _tok with | AMPERAMPER -> - 132 - | AMPERSAND -> - 131 - | AND -> - 130 - | ANDOP _ -> - 129 - | AS -> - 128 - | ASSERT -> - 127 - | BACKQUOTE -> 126 - | BANG -> + | AMPERSAND -> 125 - | BAR -> + | AND -> 124 - | BARBAR -> + | ANDOP _ -> 123 - | BARRBRACKET -> + | AS -> 122 - | BEGIN -> + | ASSERT -> 121 - | CHAR _ -> + | BACKQUOTE -> 120 - | CLASS -> + | BANG -> 119 - | COLON -> + | BAR -> 118 - | COLONCOLON -> + | BARBAR -> 117 - | COLONEQUAL -> + | BARRBRACKET -> 116 - | COLONGREATER -> + | BEGIN -> 115 - | COMMA -> + | CHAR _ -> 114 - | COMMENT _ -> + | CLASS -> 113 - | CONSTRAINT -> + | COLON -> 112 - | DO -> + | COLONCOLON -> 111 - | DOCSTRING _ -> + | COLONEQUAL -> 110 - | DONE -> + | COLONGREATER -> 109 - | DOT -> + | COMMA -> 108 - | DOTDOT -> + | COMMENT _ -> 107 - | DOTLESS -> + | CONSTRAINT -> 106 - | DOTOP _ -> + | DO -> 105 - | DOTTILDE -> + | DOCSTRING _ -> 104 - | DOWNTO -> + | DONE -> 103 - | ELSE -> + | DOT -> 102 - | END -> + | DOTDOT -> 101 - | EOF -> + | DOTLESS -> 100 - | EOL -> + | DOTOP _ -> 99 - | EQUAL -> + | DOTTILDE -> 98 - | EXCEPTION -> + | DOWNTO -> 97 - | EXTERNAL -> + | ELSE -> 96 - | FALSE -> + | END -> 95 - | FINALLY_LWT -> + | EOF -> 94 - | FLOAT _ -> + | EOL -> 93 - | FOR -> + | EQUAL -> 92 - | FOR_LWT -> + | EXCEPTION -> 91 - | FUN -> + | EXTERNAL -> 90 - | FUNCTION -> + | FALSE -> 89 - | FUNCTOR -> + | FLOAT _ -> 88 - | GREATER -> + | FOR -> 87 - | GREATERDOT -> + | FUN -> 86 - | GREATERRBRACE -> + | FUNCTION -> 85 - | GREATERRBRACKET -> + | FUNCTOR -> 84 - | HASH -> + | GREATER -> 83 - | HASHOP _ -> + | GREATERDOT -> 82 - | IF -> + | GREATERRBRACE -> 81 - | IN -> + | GREATERRBRACKET -> 80 - | INCLUDE -> + | HASH -> 79 - | INFIXOP0 _ -> + | HASHOP _ -> 78 - | INFIXOP1 _ -> + | IF -> 77 - | INFIXOP2 _ -> + | IN -> 76 - | INFIXOP3 _ -> + | INCLUDE -> 75 - | INFIXOP4 _ -> + | INFIXOP0 _ -> 74 - | INHERIT -> + | INFIXOP1 _ -> 73 - | INITIALIZER -> + | INFIXOP2 _ -> 72 - | INT _ -> + | INFIXOP3 _ -> 71 - | LABEL _ -> + | INFIXOP4 _ -> 70 - | LAZY -> + | INHERIT -> 69 - | LBRACE -> + | INITIALIZER -> 68 - | LBRACELESS -> + | INT _ -> 67 - | LBRACKET -> + | LABEL _ -> 66 - | LBRACKETAT -> + | LAZY -> 65 - | LBRACKETATAT -> + | LBRACE -> 64 - | LBRACKETATATAT -> + | LBRACELESS -> 63 - | LBRACKETBAR -> + | LBRACKET -> 62 - | LBRACKETGREATER -> + | LBRACKETAT -> 61 - | LBRACKETLESS -> + | LBRACKETATAT -> 60 - | LBRACKETPERCENT -> + | LBRACKETATATAT -> 59 - | LBRACKETPERCENTPERCENT -> + | LBRACKETBAR -> 58 - | LESS -> + | LBRACKETGREATER -> 57 - | LESSMINUS -> + | LBRACKETLESS -> 56 - | LET -> + | LBRACKETPERCENT -> 55 - | LETOP _ -> + | LBRACKETPERCENTPERCENT -> 54 - | LET_LWT -> + | LESS -> 53 - | LIDENT _ -> + | LESSMINUS -> 52 - | LPAREN -> + | LET -> 51 - | MATCH -> + | LETOP _ -> 50 - | MATCH_LWT -> + | LIDENT _ -> 49 - | METHOD -> + | LPAREN -> 48 - | MINUS -> + | MATCH -> 47 - | MINUSDOT -> + | METHOD -> 46 - | MINUSGREATER -> + | MINUS -> 45 - | MODULE -> + | MINUSDOT -> 44 - | MUTABLE -> + | MINUSGREATER -> 43 - | NEW -> + | MODULE -> 42 - | NONREC -> + | MUTABLE -> 41 - | OBJECT -> + | NEW -> 40 - | OF -> + | NONREC -> 39 - | OPEN -> + | OBJECT -> 38 - | OPTLABEL _ -> + | OF -> 37 - | OR -> + | OPEN -> 36 - | PERCENT -> + | OPTLABEL _ -> 35 - | PLUS -> + | OR -> 34 - | PLUSDOT -> + | PERCENT -> 33 - | PLUSEQ -> + | PLUS -> 32 - | PREFIXOP _ -> + | PLUSDOT -> 31 - | PRIVATE -> + | PLUSEQ -> 30 - | QUESTION -> + | PREFIXOP _ -> 29 - | QUOTE -> + | PRIVATE -> 28 - | QUOTED_STRING_EXPR _ -> + | QUESTION -> 27 - | QUOTED_STRING_ITEM _ -> + | QUOTE -> 26 - | RBRACE -> + | QUOTED_STRING_EXPR _ -> 25 - | RBRACKET -> + | QUOTED_STRING_ITEM _ -> 24 - | REC -> + | RBRACE -> 23 - | RPAREN -> + | RBRACKET -> 22 - | SEMI -> + | REC -> 21 - | SEMISEMI -> + | RPAREN -> 20 - | SIG -> + | SEMI -> 19 - | STAR -> + | SEMISEMI -> 18 - | STRING _ -> + | SIG -> 17 - | STRUCT -> + | STAR -> 16 - | THEN -> + | STRING _ -> 15 - | TILDE -> + | STRUCT -> 14 - | TO -> + | THEN -> 13 - | TRUE -> + | TILDE -> 12 - | TRY -> + | TO -> 11 - | TRY_LWT -> + | TRUE -> 10 - | TYPE -> + | TRY -> 9 - | UIDENT _ -> + | TYPE -> 8 - | UNDERSCORE -> + | UIDENT _ -> 7 - | VAL -> + | UNDERSCORE -> 6 - | VIRTUAL -> + | VAL -> 5 - | WHEN -> + | VIRTUAL -> 4 - | WHILE -> + | WHEN -> 3 - | WHILE_LWT -> + | WHILE -> 2 | WITH -> 1 @@ -1250,14 +1277,10 @@ module Tables = struct Obj.repr () | FALSE -> Obj.repr () - | FINALLY_LWT -> - Obj.repr () | FLOAT _v -> Obj.repr _v | FOR -> Obj.repr () - | FOR_LWT -> - Obj.repr () | FUN -> Obj.repr () | FUNCTION -> @@ -1332,16 +1355,12 @@ module Tables = struct Obj.repr () | LETOP _v -> Obj.repr _v - | LET_LWT -> - Obj.repr () | LIDENT _v -> Obj.repr _v | LPAREN -> Obj.repr () | MATCH -> Obj.repr () - | MATCH_LWT -> - Obj.repr () | METHOD -> Obj.repr () | MINUS -> @@ -1418,8 +1437,6 @@ module Tables = struct Obj.repr () | TRY -> Obj.repr () - | TRY_LWT -> - Obj.repr () | TYPE -> Obj.repr () | UIDENT _v -> @@ -1434,28 +1451,26 @@ module Tables = struct Obj.repr () | WHILE -> Obj.repr () - | WHILE_LWT -> - Obj.repr () | WITH -> Obj.repr () and default_reduction = - (16, "\000\000\000\000\000\000\002\221\002\220\002\219\002\218\002\217\002\172\002\216\002\215\002\214\002\213\002\212\002\211\002\210\002\209\002\208\002\207\002\206\002\205\002\204\002\203\002\202\002\201\002\200\002\199\002\198\002\171\002\197\002\196\002\195\002\194\002\193\002\192\002\191\002\190\002\189\002\188\002\187\002\186\002\185\002\184\002\183\002\182\002\181\002\180\002\179\002\178\002\177\002\176\002\175\002\174\002\173\000\000\000\000\000,\000\189\000\000\000\000\000\000\000\000\000\000\000\000\002\141\001[\000\000\000\000\000\000\000\000\000\000\000\000\000h\000c\000\191\000\000\000\000\000\000\000\000\000\000\002\159\000\000\002f\002g\000\000\002d\002e\000\000\001\178\000f\001\157\001\175\001\174\000\000\001\179\001\183\000\000\000\000\000\000\001q\001p\000\000\002\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\173\001\177\001\176\001\158\001\181\001\172\001\171\001\170\001\169\001\168\001\166\001\182\001\180\000\000\000\000\000\000\000\226\000\000\000\000\001\161\000\000\000\000\000\000\001\163\000\000\000\000\000\000\001\165\001\187\001\184\001\167\001\159\001\185\001\186\000\000\003\031\003 \000\000\000\000\000\026\001O\000\000\000\222\000\223\000\000\000\000\000\000\001\209\001\208\000\000\000\000\000\025\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001o\000\000\000\000\000\000\000\000\000\000\003\028\000\000\003\023\000\000\000\000\003\025\000\000\003\027\000\000\003\024\003\026\000\000\003\018\000\000\003\017\003\r\0022\000\000\003\016\000\000\0023\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001M\000\000\000\000\000\000\000\000\000\000\000\000\000\229\000\017\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001Y\000\000\000\000\001\\\001Z\001a\000C\002{\000\000\001\028\002\247\002\246\000\000\000\000\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\014\000\000\000\000\000\000\000e\000\000\000\237\000\000\002h\000\000\000\000\000\000\001\191\000\000\000\000\000'\000\000\000\000\000\000\000\000\000\000\000\000\001`\000\000\001P\001_\000\000\001N\000`\000 \000\000\000\000\001\134\000\027\000\000\000\000\000\000\000\000\003\012\000*\000\000\000\000\000!\000\028\000\000\000\000\000\000\000\204\000\000\000\000\000\000\000\206\002<\002.\000\000\000$\000\000\002/\000\000\000\000\001\188\000\000\000\000\000\000\000\018\000\000\000\000\000\000\000\019\002\248\000\000\002\249\000\000\000w\000\000\000\000\000#\000\000\000\000\000\000\000%\000\000\000&\000\000\000(\000\000\000\000\000)\002$\002#\000\000\000\000\000\000\000\000\000\000\000\000\000a\000\000\002\164\000d\000g\000b\002\153\003!\002\154\001\242\002\156\000\000\000\000\002\161\002c\002\163\000\000\000\000\000\000\002\167\000\000\000\000\000\000\001\238\001\229\000\000\000\000\000\000\000\000\000\000\001\228\000\000\001\241\002\170\000\000\000\000\000\000\000\000\001\136\000\000\000\000\001\240\002\162\000o\000\000\000\000\000n\000\000\002\155\000\000\000\000\000\000\000\000\002\169\000\000\000\000\000\000\001\230\001\239\001\233\000\000\000m\000\000\002\168\000\000\002\166\000\000\002i\000\000\000\000\002F\002\165\000\000\000\000\000\000\000\000\001\193\0017\0018\002k\000\000\002j\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\248\000\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\250\000\000\000\000\000\000\000\000\000\000\000\000\000\246\001\249\000\247\000\000\000\000\000\000\000\000\000\000\000\250\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\207\000\000\000\000\000\000\000\000\000\000\000\000\002 \000\000\000\000\001x\000\000\000\000\000\000\000\000\000\000\000\000\0038\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\015\000\000\000\000\000\000\000\000\000\000\001w\000\000\000\000\000\000\001X\001~\001W\001{\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\002-\002\031\000\000\001v\000\000\000\208\000\000\000\000\001i\000\000\000\000\001m\000\000\001\211\000\000\000\000\001\210\001l\001j\000\000\001n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\127\001]\002\132\002\130\000\000\000\000\000\000\002\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\152\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\241\000\240\000\000\000\242\000\000\000\000\000\000\002\138\000\000\000\000\000\000\002p\000\000\000\000\000\000\000\000\003\"\002\140\002\129\002\128\000\000\000\000\000z\001:\000\000\000\000\000\173\000\000\000\000\000\000\000\000\000\000\000\187\000\000\000\000\000\000\000\172\000\000\000\000\000\000\002M\002L\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\003\000\000\000\000\001\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\246\001\244\001\245\000\000\000\000\000\000\000\252\000\000\000\000\000\000\000\000\000\000\000\000\001\255\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\024\000\000\001d\002\240\000\000\000\000\002\239\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\245\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\001\138\000\000\002\005\000\000\000\000\000\000\000\000\000i\000\000\000\000\000j\000\000\000\000\000\000\000\000\001\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\231\000\000\000\000\000s\000\000\000\234\000\232\000\000\000\000\000\000\000\211\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\223\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002N\000k\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\149\001\145\000\000\000\000\000\000\000\216\000\000\000\000\002\019\002\029\000\000\000\219\002\017\002\018\000\000\000\000\000\000\000\000\000\000\001\152\001\148\001\144\000\000\000\000\000\217\000\000\000\000\001\151\001\147\001\143\001\141\002\029\000\000\000\221\000\000\000\000\002\007\000\000\000\000\002W\002\028\002\026\002\027\000\000\000\000\000\000\002\029\000\000\000\218\002\029\000\000\000\220\000\000\000\000\000\000\000\000\002V\000\000\000\000\000\000\000\000\000\000\000\000\001\156\000\000\000\000\000\000\001\155\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\001r\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\026\002\\\000\000\000\000\000\000\002Z\000\000\000\000\000\000\002Y\000\000\001f\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\003*\000\000\000\000\000\000\000\196\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G\000\000\000\000\000\000\000\000\001\133\000\000\001\132\000\000\000\000\000\000\000\000\000J\000\000\000\000\000\000\002\012\000\000\002\011\000\000\000\000\000\000\000\000\000K\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000P\000\000\000\000\000\000\000Q\000O\000\000\000S\000\000\000\000\000\000\000\000\000\000\000I\000\000\000\000\000\000\000\000\000\000\000\000\000L\000\000\000R\000\000\000M\000N\000\000\001+\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\022\000_\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\\\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\020\002a\002R\000\000\002X\002S\002_\002^\002]\002[\001%\000\000\002P\000\000\000\000\000\000\000\000\000\000\002\029\000\000\000\000\001\030\002T\000\000\000\000\000\000\000\000\000\000\000\000\002\029\000\000\000\000\001 \002U\002Q\002b\001$\001\252\002O\000\000\000\000\000\000\000\000\000\000\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\000\000\000\003'\000\000\0008\000\000\000\000\003-\000\000\003,\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003$\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\001L\000\000\000\000\001J\001H\000\251\000\000\000\000\000\000\000\198\000\197\002\225\000\000\0009\000\000\000\000\0030\000\000\003/\000\000\000\000\000\000\001F\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001K\000\000\000\000\001I\001G\000\000\000\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\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000X\000\000\000\000\000\000\000\000\000\000\000\000\0005\000\000\000\000\000\000\000\000\000\000\002\"\002!\000W\000\000\0003\001\b\000\000\000B\000/\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\006\000\000\000V\000\000\000\000\000Y\000\000\000\000\001\195\000\000\0007\000\000\000\000\000\000\0006\000\000\000\000\000\000\000:\000\000\000Z\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\001\018\002\243\002\234\000\000\000\000\000\000\000\000\000\000\000\000\001\004\002\238\002\222\002\233\002\242\002\241\000\000\001;\001)\000\000\001\005\000\000\002\231\000\000\002\235\002\232\002\244\001\251\000\000\000\000\002\228\000\000\000\194\000\000\002\227\000\000\000\000\000\228\000\000\002\004\000\020\000\000\000\000\000\000\002r\000\000\000\000\002q\000\000\000\000\000\000\000\000\002t\000\000\000\000\002@\000\000\000\000\002x\000\000\000\000\002v\002\135\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\002s\000\000\000\000\002w\000\000\000\000\002u\001\r\000\000\000\000\001\014\000\000\000\000\000\174\000\000\001\016\001\015\000\000\000\000\002\136\000\000\002\148\000\000\002\147\000\000\002\151\000\000\002\150\000\000\000\000\002\137\000\000\000\000\000\000\002\016\000\000\001\207\000\000\000\000\000\000\002I\002\015\000\000\002\144\000\000\000\000\000\000\001^\000\000\000x\000y\000\000\000\000\000\000\000\000\000\144\000\000\000\000\000\000\000\130\000\000\000\000\000\000\000\000\000\000\000\000\000\129\000\199\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200\000\000\000\201\000\202\000\138\000\000\000\137\000\000\000\000\001=\000\000\001>\001<\002(\000\000\000\000\002)\002'\000\000\000\000\000\000\000\000\000\000\002z\000\000\002y\000\000\000\000\002l\000\000\000\000\002\143\000\000\000\000\000\000\002C\002\134\000\000\002\133\000\000\002\149\000\135\000\000\000\000\000\000\000\000\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\132\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\133\002\224\002\226\001\011\001\205\000\000\000\244\000\245\000\000\000\000\000\000\000\000\000\000\000\000\001\001\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\255\000\254\000\000\0019\000\000\002\146\000\000\002\145\002\131\000\000\000\000\000\000\000\000\002|\000\000\000\000\002}\000\000\002n\000\000\002o\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\212\000\000\000\000\001\215\000\000\000\000\001\213\000\000\000\000\001\214\000\000\001\154\000\000\000\000\000\000\001\153\000\000\000\000\001(\001'\000\000\000\190\000\000\000\000\000\000\000\000\001E\001?\000\000\000\000\001@\000\031\000\000\000\030\000\000\000\000\000\205\000\000\000\000\000\000\000\"\000\029\000\000\000\000\000\000\000\023\000\000\000\000\000\000\000\000\001\150\001\146\000\000\001\142\003\011\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\192\000\000\002\237\002\024\002\025\002\020\002\022\002\021\002\023\000\000\000\000\000\000\000\193\000\000\000\000\000\000\000\000\000\000\000\000\002\236\000\000\001g\000\000\000\000\000\024\000\000\003(\000\000\001s\000\000\002\158\000\000\000D\000\000\000\000\000E\000\000\000\000\002~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\000\000\000~\000\000\000\000\000\000\000\143\000\000\000-\000\000\000\000\000\000\000\000\000\128\000\000\000\224\000\001\000\000\000\000\000\227\000\002\000\000\000\000\000\000\001R\001S\000\003\000\000\000\000\000\000\000\000\001U\001V\001T\000\021\001Q\000\022\000\000\001\216\000\000\000\004\000\000\001\217\000\000\000\005\000\000\001\218\000\000\000\000\001\219\000\006\000\000\000\007\000\000\001\220\000\000\000\b\000\000\001\221\000\000\000\t\000\000\001\222\000\000\000\n\000\000\001\223\000\000\000\011\000\000\001\224\000\000\000\000\001\225\000\012\000\000\000\000\001\226\000\r\000\000\000\000\000\000\000\000\000\000\003\000\002\251\002\252\002\255\002\253\000\000\003\004\000\014\000\000\003\003\000\000\001/\000\000\000\000\003\001\000\000\003\002\000\000\000\000\000\000\000\000\0013\0014\000\000\000\000\0012\0011\000\015\000\000\000\000\000\000\003\030\000\000\003\029") + (16, "\000\000\000\000\000\000\003\014\003\r\003\012\003\011\003\n\002\221\003\t\003\b\003\007\003\006\003\005\003\004\003\003\003\002\003\001\003\000\002\255\002\254\002\253\002\252\002\251\002\250\002\249\002\248\002\247\002\220\002\246\002\245\002\244\002\243\002\242\002\241\002\240\002\239\002\238\002\237\002\236\002\235\002\234\002\233\002\232\002\231\002\230\002\229\002\228\002\227\002\226\002\225\002\224\002\223\002\222\000\000\000\000\000\"\000~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\212\001\191\001\209\001\208\001\207\001\213\001\217\001\211\001\210\001\192\001\215\001\206\001\205\001\204\001\203\001\202\001\200\001\216\001\214\000\000\000\000\000\000\001\004\000\000\000\000\001\195\000\000\000\000\000\000\001\197\000\000\000\000\000\000\001\199\001\221\001\218\001\201\001\193\001\219\001\220\000\000\003N\003O\000\000\000\000\000 \001n\000\128\000\000\001\000\001\001\000\000\000\000\000\000\001\246\001\245\000\000\000\000\000\031\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003K\000\000\003F\000\000\000\000\003H\000\000\003J\000\000\003G\003I\000\000\003A\000\000\003@\003<\002]\000\000\003?\000\000\002^\000\000\000\000\000\000\000\000\000_\000\000\000\000\000]\000\000\000\000\001l\000\000\000\000\000\000\000\000\000\000\002\190\001z\000\000\000\000\000\000\000\000\000\000\000\000\002F\000\000\000\000\000\000\000\000\000\000\000\000\000Z\000\000\000\000\000\000\000\000\000\000\002\208\000\000\002\150\002\151\000\000\002\148\002\149\000\000\000\000\000\000\000\000\000\000\001\144\001\143\000\000\002\206\000\000\000\000\000\000\000\000\000\000\001\142\000\000\000\000\000\000\001\007\000\017\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001x\000\000\000\000\001{\001y\001\128\000:\002\172\000\000\001>\003&\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\001\015\000\000\002\152\000\000\000\000\000\000\001\225\000\000\000\000\000x\000\000\000\000\000\000\000\000\000\000\000\000\001\127\000\000\001o\001~\000\000\001m\000W\000\027\000\000\000\000\001\166\000\024\000\000\000\000\000\000\000\000\000o\000\000\000\000\000\000\000\000\000\000\000\000\003;\000\238\000p\000\131\000q\000\023\000\000\000\000\000\000\000\000\000\028\000\025\000\018\000\000\000r\000n\000\000\000\000\000\000\000\019\000\030\000\000\000\240\002k\002Y\000\000\000u\000\000\002Z\000\000\000\000\001\222\000\000\000\000\000\000\000\000\003'\000\000\003(\000\000\000\000\000t\000\000\000\000\000\000\000v\000\000\000w\000\000\000y\000\000\000\000\000z\002O\002N\000\000\000\000\000\000\000\000\000\000\000\000\000X\000\000\002\213\000[\000^\000Y\002\202\003P\002\203\002\027\002\205\000\000\000\000\002\210\002\147\002\212\000\000\000\000\000\000\002\216\000\000\000\000\000\000\002\023\002\014\000\000\000\000\000\000\000\000\000\000\002\r\000\000\002\026\002\219\000\000\000\000\000\000\000\000\001\168\000\000\000\000\002\025\002\211\000f\000\000\000\000\000e\000\000\002\204\000\000\000\000\000\000\000\000\002\218\000\000\000\000\000\000\002\015\002\024\002\018\000\000\000d\000\000\002\217\000\000\002\215\000\000\002\153\000\000\000\000\002x\002\214\000\000\000\000\000\000\000\000\001\227\001Y\001Z\002\155\000\000\002\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\026\001\027\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002K\000\000\000\000\001\151\000\000\000\000\000\000\000\000\000\000\000\000\003g\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003>\000\000\000\000\000\000\000\000\000\000\001\150\000\000\000\000\000\000\001w\001\158\001v\001\155\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002W\000\000\000\000\002X\002J\000\000\000\000\001\149\000\000\000\242\000\000\000\000\001\136\000\000\000\000\001\140\000\000\001\248\000\000\000\000\001\247\001\139\001\137\000\000\001\141\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\024\002\"\001\025\000\000\000\000\000\000\000\230\000\000\001\028\001\029\000\000\000\231\002I\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002T\002R\000\000\000\000\000\000\000\000\000\000\000\000\002\176\001|\002\181\002\179\000\000\000\000\000\000\002\191\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\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\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\019\001\018\000\000\001\020\000\000\000\000\000\000\002\187\000\000\000\000\000\000\002\161\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003Q\002\189\002\178\002\177\000\000\000\000\000\203\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\229\000\000\000\000\000\000\000\000\000\000\000\000\000\202\000\201\000\000\000\000\000\000\000\236\000\235\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\017\000\000\000\000\000\000\000\000\000\000\000\000\001#\000\000\000\000\002Q\000\000\000\000\000\000\001\"\000\000\000\000\001!\001 \000\000\001\244\000\000\000\000\000\136\003\018\002H\000\000\000\000\000\000\000\000\001%\000\000\000\000\001$\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\031\002\029\002\030\000\000\000\000\000\000\001\030\000\000\000\000\001D\000\020\001'\000\000\000\000\000\000\002\163\000\000\000\000\002\162\000\000\000\000\000\000\000\000\002\165\000\000\000\000\002q\000\000\000\000\002\169\000\000\000\000\002\167\002\184\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002M\002L\000\199\002r\000\000\002\164\000\000\000\000\002\168\000\000\000\000\002\166\001/\000\000\000\000\0010\000\000\000\000\000\204\000\000\0012\0011\000\000\000\000\002\185\000\000\002\197\000\000\002\196\000\000\002\200\000\000\002\199\000\000\000\000\002\186\000\000\000\000\000\000\0029\000\000\000\000\000\000\000\000\002{\0028\000\000\002\193\000\000\000\000\000\000\001}\000\000\000{\000|\000\000\000\000\000\000\000\000\000\152\000\000\000\142\000\000\000\000\001\\\000\000\001]\001[\002S\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\171\000\000\002\170\000\000\000\000\000\000\000\000\000\000\002\157\000\000\002\156\000\000\000\000\002\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002u\002\183\000\000\002\182\000\000\002\198\000\141\000\000\000\000\000\000\000\000\000\140\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\138\000\000\001\131\000\000\000\000\000\000\000`\000\000\000\000\000a\000\000\000\000\000\000\000\000\001\160\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\t\000\000\000\000\000j\000\000\001\012\001\n\000\000\000\000\000\000\000\245\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\139\000b\000\000\000\000\0027\000\000\000\000\001&\001\242\000\000\001\022\001\023\001-\000\000\000\000\000\000\000\000\000\000\002\195\000\000\002\194\002\180\000\000\000\000\000\000\000\000\002\173\000\000\000\000\002\174\000\000\002\159\000\000\002\160\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\250\000\000\000\000\002\000\000\000\000\000\001\252\000\000\000\000\001\254\000\000\001\249\000\000\000\000\001\255\000\000\000\000\001\251\000\000\000\000\001\253\000\000\001\188\000\000\000\000\000\000\001\187\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\156\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001:\003\031\000\000\000\000\003\030\000\000\000\000\000\000\000\000\000\000\002(\000\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\001\170\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\003\016\000\000\000\000\002~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\190\000\000\000\000\000\000\001\189\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\157\000\000\000\000\000\000\000\000\000\000\001\145\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001<\002\140\000\000\000\000\000\000\002\138\000\000\000\000\000\000\002\137\000\000\001\133\000\000\000\000\000\000\000\000\002\144\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003Y\000\000\000\000\000\000\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000>\000\000\000\000\000\000\000\000\001\165\000\000\001\164\000\000\000\000\000\000\000\000\000A\000\000\000\000\000\000\0025\000\000\0024\000\000\000\000\000\000\000\000\000B\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G\000\000\000\000\000\000\000H\000F\000\000\000J\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000C\000\000\000I\000\000\000D\000E\000\000\001M\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0018\000V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000S\000\000\000U\000T\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0016\002\145\002\130\000\000\002\136\002\131\002\143\002\142\002\141\002\139\001G\000\000\002\128\000\000\000\000\000\000\000\000\000\000\002F\000\000\000\000\001@\002\132\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\181\001\177\000\000\000\000\000\000\000\250\000\000\000\000\002<\002F\000\000\000\000\001B\002:\002;\000\000\000\000\000\000\000\000\000\000\001\184\001\180\001\176\000\000\000\000\000\251\000\000\000\000\001\183\001\179\001\175\001\173\002\133\002\129\002\146\001F\002%\002\127\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003T\000\000\000\000\003V\000\000\000/\000\000\000\000\003\\\000\000\003[\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003S\000\000\000\000\003U\000\000\000\000\000\000\0020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001k\000\000\000\000\001i\001g\000\000\0000\000\000\000\000\003_\000\000\003^\000\000\000\000\000\000\001e\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001j\000\000\000\000\001h\001f\000\000\000\000\000\000\0002\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\000O\000\000\000\000\000\000\000\000\000\000\000\000\000,\000\000\000\000\000N\000\000\000*\001*\000\000\0009\000&\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001(\000\000\000M\000\000\000\000\000P\000\000\000\000\001\229\000\000\000.\000\000\000\000\000\000\000-\000\000\000\000\000\000\0001\000\000\000Q\000\000\0003\0004\000\000\001O\000\000\000\000\000\000\000\000\000\000\000\000\0007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0014\003\"\003\025\000\000\000\000\003\029\003\015\003\024\003!\003 \001K\000\000\000\000\003\022\000\000\003\026\003\023\003#\002$\000\000\000\000\003\020\000#\003\019\000\000\000\000\000\132\000\000\001\006\000\000\000\000\001J\001I\000\000\001\134\000\000\000\000\002\207\000\000\000;\000\000\000\000\000<\000\000\000\000\002\175\000\000\000\000\000\000\000\000\002-\000\255\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\129\000\000\003\028\002A\002B\002=\002?\002>\002@\000\000\000\000\000\000\000\130\000\000\000\000\002F\000\000\000\254\000\000\000\000\000\000\000\000\003\027\000\000\000\127\000\000\000\000\000\000\000\000\001d\001^\000\000\000\000\001_\001\186\000\000\001\185\000\000\000\000\000\239\000\000\000\000\000\000\000\029\000\026\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\182\001\178\000\000\001\174\003:\000\000\002F\000\000\000\253\000\000\000\000\000\000\000\000\002\135\002E\002C\002D\000\000\000\000\000\000\002F\000\000\000\252\000\000\000\000\000\000\000\000\002\134\000\000\001\146\000\000\000s\000\000\003W\000\000\000$\000\000\000\000\000\000\000\000\000\151\000\000\001\002\000\001\000\000\000\000\001\005\000\002\000\000\000\000\000\000\001q\001r\000\003\000\000\000\000\000\000\000\000\001t\001u\001s\000\021\001p\000\022\000\000\002\001\000\000\000\004\000\000\002\002\000\000\000\005\000\000\002\003\000\000\000\000\002\004\000\006\000\000\000\007\000\000\002\005\000\000\000\b\000\000\002\006\000\000\000\t\000\000\002\007\000\000\000\n\000\000\002\b\000\000\000\011\000\000\002\t\000\000\000\000\002\n\000\012\000\000\000\000\002\011\000\r\000\000\000\000\000\000\000\000\000\000\003/\003*\003+\003.\003,\000\000\0033\000\014\000\000\0032\000\000\001Q\000\000\000\000\0030\000\000\0031\000\000\000\000\000\000\000\000\001U\001V\000\000\000\000\001T\001S\000\015\000\000\000\000\000\000\003M\000\000\003L") and error = - (133, "3\248H1b\171\1273=\001@}\200\160\001\199\001\141\194\000\139\133\027\248\147\232\002\003\232\005\000\0068\023\183d@\130\254*@\0010p:q\193`Ph\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\223\235f\245\155\175\252\205\255%C\247\018\162\015<\011\219\178 A\127\021 \000\1528\0298\224\176(4\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012n\016\004X(\223\196\159@\016\031@(\0001\192\189\187\"\004\023\241R\000\t\131\129\211\142\011\002\131C?\132\139V*\183\2433\208\020\007\220\n\000\128 >\128P\000c\128\198\225\000E\130\141\252I\244\001\001\244\002\128\003\028\0067\b\002,\020o\226G\160\b\015\160\020\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012n\016\004\\(\223\196\159@\016\031@(\0001\192cp\128\"\193F\254$\250\000\128\250\001@\001\142\003\027\132\001\022\n7\241#\208\004\007\208\n\000\012p\024\220 \b\184Q\191\137>\128 >\128P\000c\128\198\225\000E\130\141\252I\244\001\001\244\002\128\003\028\0067\b\002,\020o\226G\160\b\015\160\020\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\016\128\"\001@0$r\000\000\n\001@\001\140\000 \000\002\001\000\t\002\020\012\000\000\000@\b\000\000\001\000\000\016\000\000H\016\160`\000\000\002\000@\000\000\b\000\000\128\000\002@\132\003\000\000\000\016\002\000\000\0001\b\002\004\000#\002E\160\002\000\168\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0001\012B?\001cJE\167\198 \172\b\001\146\203\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\128\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\001\128\000\000\016\000\000\000@\000\000\000\000\000\000\000\000\012\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\000\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\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\002\002\000\001\003\002\000\000\000\016\000\000\000\000\000B@\n\160\002\012\021!\192\001\016\000\236\b\025\000 \018\000A\000\016@\001\n\000\b\000\006 \000\b\000\000\144\002\b\000\130\000\b@\000@\0001\000\000@\000\000\000\000\000 \0000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\001\128\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\000\000\000\128\007\224\012\t\000\000\248\132\000\129\000 Q`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\002\128\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\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\016\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\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\136\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\192\000\014\002\000\012.\016\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\128Y\208\004\025\026C\129\131\"\001\216\017\"\017@\000\000\000\000\000\000\128\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\001\128\000\028\004\b\024\\ \000\016\000\000\000\000\000\000\004\000\000\000\000\000@\000\000\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 \0160 \128\000\001\000\000\000\000\000\000\b\001\001\000\000\129\129\004\000\000\b\000\000\000\000\000\000@\b\b\000\004\012\b\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\001\128\128\016\000\000\016\016@\000\000\128\000\000\000\000\000\012\004\000\128\000\000\128\128\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000g\240\144b\197V\254f\250\002\128\251\137@\003\142\003?\132\131\022*\183\2433\208\020\007\220J\000\028p\000\192\000\004\152 \140\000 \004\000\000\000\000\000\002\000\006\000\000$\129\004`\001\000 \000\000\000\000\000\016\0000\000\001$\b#\000\000\001\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000@\000\000\000\000\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\000\018@\0020\000\000\016\000\000\000\000\000\b\000\016\000\000\128\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000$\128\004\000\000\000 \000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\b \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\002\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\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\002\000\000\018@\002\000\000\000\016\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\t\000\"\130\b \020\134\000\004@\003\176\002\004\000\1281\000\003\192\128\003\011\133\000\002\000 \002\000\001\000\002@\b\160\003\b\021!\192\001\016\000\204\b\131\b \012@\000\224 \000\194\225@\000\128\b\000\128\000@\000`\000\135\001\002\006\023\b\000\004\000\000\000\001\000\000\133\128]\192\004\025\026C\129\130\"\001\216\001f\017`\024\000\001\128\000\001\133\194\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\006\000\000`\000\000ap\128\000D\000\000@\000\000\000\016\000\128\000\000\001\000\000\000\002 \000\000\000@\000\001\128\000\028\004\000\024\\ \000\016\000\000\000\000\000\002\246\236\136\016_\197H\000&\014\007N8,\n\r\012\254\018-X\170\223\204\207@P\031p(\000\241\192g\240\145b\197V\254fz\002\128\251\153@\003\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\016\002\002\000\002\002\b\000\000\016\000\000\000\000\128\001\128\128\016\016\000\016\016@\000\000\128\000\000\000\000\000\012\004\000\128\000\000\128\130\000\000\004\000\000\000\000\000\000` \004\000\000\004\004\000\000\000 \000\000\000\000\000\007\001\000 \000\000 \000\000\001\000\000\000\000\000\003\027\132\001\022\n7\241'\208\004\007\208\n\000\012p\024\220 \b\176Q\191\137\030\128 >\128P\000c\128\002\000\000\000@\000 \001\000\000\000\000\000\000\000\000\000\016\000\000\000\000\001\000\b\000\000\000\000\000\000\000\000\000\128\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\191\214\239\2517\223\251\255\254N\143\238e\132\014y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\024\220 \b\184Q\191\137>\128 >\128P\000c\128\198\225\000E\130\141\252I\244\001\001\244\002\128\003\028\0067\b\002,\020o\226G\160\b\015\160\020\000\024\2241\184@\017p\163\127\018}\000@}\000\160\000\199\001\141\194\000\139\005\027\248\147\232\002\003\232\005\000\0068\012n\016\004X(\223\196\143@\016\031@(\0001\192cp\196#\241V\254\164z|\194\250A\192\025\174\176\024\132!\016\n\001\129#\144\000\000P\n\000\012`\024\220 \b\176Q\191\137\030\128 >\128P\000s\129\015=\187\215\250\190w\207\239\254\220\031\191\182\255\249\2307\b\002,\020o\226G\160\b\015\160\020\000\024\224\001\136A\0160\001\024\018m\000\016\005\000\000\000\130\000\012B\b\129\000\b\192\147h\000\128(\000\000\004\016\000b\016D\b\000F\004\139@\004\001@\000\000 \128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\024\132\001\002\000\017\129\"\208\001\000P\000\000\b \000\196 \b\016\000\140\t\022\128\b\002\160\000\000Q\000\006!\002@\128\004`H\180\000@\021\000\000\002\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000D\000\000\000\000\000\000\000\000\002\000\000 \000\000\192\000\014\002\000\012.\016\000\b\000\000\000\000\000\000\006\000\000p\016\000ap\128\000@\000\000\000\000(\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\128\000\028\004\000\024\\ \000\016\000\000\000\000\002\000\012\000\004\224 \000\194\225\000\000\128\000\000\000\000P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\0008\b\0000\184@\000 \000\000\000\000\004\000\024\000\001\192@\001\133\194\000\001\000\000\000\000\000\160\000@\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000 \000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\016\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\000\224 \000\194\225\000\000\128\000\000\000\000\016\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\000\000\000\000\000\000\000\000\000! \007p\001\006B\144\224`\136\128v\000X\132X\006\000\000p\016\000ap\128\000@\000\000\000\000\000\bH\005\220\000A\144\1648\024\" \029\128\022!\022\001\128\000\024\000\000\024\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\133\128]\192\004\025\026C\129\130\"\001\216\001b\017`\b\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\003\000\000\003\011\132\000\002\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\012\000\000\224 \000\194\225\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\133\128]\192\004\025\026C\129\130\"\001\216\001b\017`\024\000\001\128\000\001\133\194\000\001\000\000\000\000\000\000!`\023p\001\006F\144\224`\136\128v\000X\132X\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\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\0008\b\0000\184@\000 \000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\128\000\000 \000\000\128\000\000\000\004\000\006\000\000p\016\000ap\128\000@\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\128\000\028\004\000\024\\ \000\016\000\000\000\000\000\000\000\000\004\000\000\000\000\002\000\000\b\000\000\000\000@\128`\000\007\001\000\006\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\004\000\000\016\000\000\000\000\137\000\000\000\004\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\002\000\000\b\000\000\000\000D\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\128\000\002\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \007p\001\006B\144\224`\136\128v\000X\132P\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\b\000\012\000\000\224 \000\194\225\000\000\128\000\000\000\000\016\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\b\000\000\000\000\000\000\000\000\000\000\000\000\128\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\004\000\000\000\000 \000\000\000\000\000\000\000\000\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\004\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\016\000\000\000\000\000\000\017\000\000\000\000\000\000\000\000\000\128\000\000\000\0001\b\002\004\000#\002E\160\002\000\168\000\000\016@\001\136@\0160\001\024\018i\000\016\005\000\000\000\130\000\012B\000\129\000\b\192\147H\000\128(\000\000\004\016\000b\016\004\b\000F\004\138@\004\001@\000\000 \128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000&)\027P\144\020`I\172\002@\020\160@\218\170\000\000\b\000\004\000 \000\000 \000\000\128\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\019\020\141\168H\n0$\222\001 \n\208\016mU\000\b\000\000\000\000\001\000\"\128\000\000\000\000\000\000\000\000\196!\b\016\000\140\t\022\128\b\002\160\000\002A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0001\b\002\006\000#\002M\160\002\000\168\000\000\016@\001\136@\016 \001\024\018m\000\016\005@\000\000\130\000\012B\000\129\000\b\192\145h\000\128*\000\000\004\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000l\000\000@\000\004\000\b\000\002\128\002b\136\000\196 \b\016\000\140\t\022\128\b\002\160\000\000A\000 \000\027\000\000\016\000\001\000\002\000\000\160\000\152\162\0001\b\002\004\000#\002E\160\002\000\168\000\000\016@\b\000\006\192\000\004\000\000@\000\128\000(\000&(\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002b\017\180\b\001F\004\155@$\001Z\000\t\170\160\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\196#h\016\002\140\t6\128H\002\180\000\019U@\007!\136G\224,iH\180\248\196\021\129\0002Y`\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\b\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\003\016\128 @\0020$R\000 \n\000\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000 \000\000\128\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\128\000\000\000\000\016\000\000\000\000\000\t\130 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\024\132\001\002\000\017\129\"\208\001\000T\000\000\b \004\000\003`\000\002\000\000 \000@\000\020\000\019\020@\006\000\000p\016\000ap\128\000@\000\000\000\000\000\000\000\000@\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012B\000\129\000\b\192\145h\000\128*\000\000\004\016\002\000\001\176\000\001\000\000\016\000 \000\n\000\t\138 \000\000\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\002\000\000\000\000\000\001 D\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\016\129 @\0020$Z\000 \n\128\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\000\000\000\000\b\000\000\000\000\000\004\133\016\001\136@\144 \001\024\018-\000\016\005@\000\000\162\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\128\000\000\000\000\128\000\000\000\000\000H\017\000\000\000D\000\000\000\000\000\000\000\000\000\000\000\000\000\000\192\000 \000\000\004\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\229$Z\019\004\142\153\245\128\200\002\246\000\027\197P\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\002\000\000\000\000\000\000\000\000\000 \000\002\000\000\012\000\000\224 \000\194\225\000\000\128\000\000\000\000\000\000\000\000\128\000\000\000\000\016\000\000\000\b\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\002\000\000\000\000\000\000\000\000\000 \000\000\000\001\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\000b\016\004\b\000F\004\139@\004\001@\000\000 \128\003\020\128(H\0020$\214\001 \n@\000M\021\128\016\000\000\000\000\001\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006!\000@\128\004`H\180\000@\021\000\000\002\b\000\000\000@\000\000\000\000\b\000\000\000\004\000\004\193\016\001\128\000\028\004\000\024\\ \000\016\000\000\000\000\000\000\000\000\016\000\000\000\000\002\000\000\000\001\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0009\012B?\001cJE\167\198 \172\b\001\146\203\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000b\144\005\t\000F\004\138\192\004\001H\000\004\160\128\003\016\128 @\0020$R\000 \n\000\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\024\220 \b\176Q\191\137\030\128 >\128P\000c\128\006!\004@\200$`I\180\000@\021\000\000\002\b\0000\016\002\002\000\002\002\b\000\000\016\000\000\000\000\128\001\128\128\016\016\000\016\016@\000\000\128\000\000\000\000\000\012\004\000\128\000\000\128\130\000\000\004\000\000\000\000\000\000` \004\000\000\004\004\000\000\000 \000\000\000\000\000\000\000\000\000\000\000 \000\128\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\192\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\128\016\016\000\b\024\016\000\000\000\128\000\000\000\000\000\004\000\128\128\000@\192\128\000\000\004\000\000\000\000\000\000\000\000\000\000\000\004\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\016\002\002\000\001\003\002\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\018\000U\000\016`)\014\000\b\128\007`\000\136\001\000\016\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\003\000\000\018@\0020\000\000\016\000\000\000\000\000\b\000\b\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\004\000\000\006\000\000x\016\000ap\128\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\128\000\028\004\000\024\\ \000\016\000\000\000\000\000\002\018\000U\000\016`)\014\000\b\128\007`\000\136\005\000`\000\007\001\000\006\023\b\000\004\000\000\000\000\000\000\132\128\021@\004\024\nC\128\002 \001\216\001\"\001D$\000\170\000 \192R\028\000\017\000\014\192\t\016\002\000\192\000\014\002\000\012.\016\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\128\000\000\000\0000\000\003\128\128\003\011\132\000\002\000\000\000\000\000\000B@\n\160\002\012\005!\192\001\016\000\236\000\145\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\128\000\000@\b\b\000\004\012\b\000\000\000@\000\000\000\000\001\t\000*\128\b0\020\135\000\004@\003\176\000D\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\b\000\000\000\004\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\016\144\002\168\000\131\005Hp\000D\000;\002\006@\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\002\002\000\001\003\002\000\000\000\016\000\000\000\000\000B@\n\160\002\012\005!\192\001\016\000\236\000\017\000 \004\000\128\128\000@\192\128\000\000\004\000\000\000\000\000\016\144\002\168\000\131\001Hp\000D\000;\000\004@\b\000\000\000\000\000\000\000\000\000\000\000\000@\016\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000! \005P\001\006\n\144\224\000\136\000v\004\b\128\016\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000B@\n\160\002\012\021!\192\001\016\000\236\b\017\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\144\002\168\000\131\001Hp\000D\000;\000\004@\b\000\128\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\b\000\000\016\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\002\000\000\004\000\000@\000\000\000\000\000\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\003\001\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! \005P\001\006\n\144\224\000\200\000v\000\t\128\016\014\002\b@\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\002\000\000\000\016\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 \004\004\000\002\006\004\000\000\000 \000\000\000\000\000\128\000\004\000\000\b\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bH\001T\000A\130\1648\0002\000\029\129\002`\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\002\000\004\000\000\000\000\000\000\012n\016\004X(\223\196\143@\016\031@(\0001\192cp\129\"\193F\254$z\000\128\250\001@\001\142\000\000\000\000\000\000\000\128\000\000\000@\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\002\000\016\000\000\000\000\198\225\000E\130\141\252H\244\001\001\244\002\128\003\028\0001\b\002 \020\003\002G \000\000\160\020\000\024\192@\000\004@\000\000\000\000\000\0000\000 H\018\000\000\012B\000\136\005\000\192\145\200\000\000(\005\000\0060\012n\016\004X(\223\196\143@\016\031@(\0001\192\003\016\128\"!@0$\242\000\000\n\001@\001\140\000\024\132\001\016\n\001\129'\144\000\000P\n\000\012`\000\196 \b\128P\012\t\028\128\000\002\128P\000c\000\198\225\000E\194\141\252I\244\001\001\244\018\128\003\028\0067\b\002,\020o\226O\160\b\015\160\148\000\024\2241\184@\017`\163\127\018=\000@}\004\160\000\199\001\141\194\000\139\133\027\248\147\232\002\003\232\005\000\0068\012n\016\004X(\223\196\159@\016\031@(\0001\192cp\128\"\193F\254$z\000\128\250\001@\001\142\000\024\132\001\003\000\017\129&\208\001\000T\000\000\b\160\000\196 \b\016\000\140\t6\128\b\002\160\000\000E\000\006!\000@\128\004`H\180\000@\021\000\000\002(\0001\b\002\004\000#\002E\160\002\000\168\000\000\016@\b\000\000\000\000\004\000\000@\000\000\000\000\000$\b\129\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\000b\144\005\r\000F\004\154\192\004\001@\000\000 \128\003\020\128(H\0020$\214\000 \n\000\000\001\004\000\024\164\001B@\017\129\"\176\001\000P\000\000\b \000\2281\b\252\005\141)\022\159\024\130\176 \006K,\000\000\000\000\000\000 \000\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\138@\020$\005\024\018+\000\016\005\000\000\002\130\001\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\000b\016\004\012\000F\004\155@\004\001P\000\000 \128\003\016\128 @\0020$\218\000 \n\128\000\001\004\000\024\132\001\002\000\017\129\"\208\001\000T\000\000\b \000\000\000\000\000\000\000\000 \000@\000\016\000\018\004@\198\225\000E\130\141\252H\244\001\001\244\002\128\003\028\0001\b\002\006\000#\002M\160\002\000\168\000\000\016@\001\136@\016 \001\024\018m\000\016\005@\000\000\130\000\012B\000\129\000\b\192\145h\000\128*\000\000\004\016\000\000\000\000\000\000\000\000\016\000\000\000\b\000\t\002 cp\128\"\193F\254$z\000\128\250\001@\001\142\000\024\132\001\016\n\001\129#\144\000\000P\n\000\012`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\030{w\175\245|\235\159\223\253\184?\127m\255\247\192 \000\000\000\000\006\000\142\000\000\000\000\000\000\000\000cp\196#\241V\254\164z|\194\250A\192\025\174\176\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\024\220!\b\176Q\191\137\030\128 >\128P\000c\128\198\225\bE\130\141\252H\244\001\001\244\002\128\003\028\0000\016\002\002\000\002\002\b\000\000\016\000\000\000\000\000\001\128\128\016\000\000\016\016@\000\000\128\000\000\000\000\000\012\004\000\128\000\000\128\128\000\000\004\000\000\000\000\000\000\000\000\000\000\000\004\000\016\000\000\000\000\000\000\128\000\001\000 \000\0160 \000\000\001\000\000\000\000\000\004\000\000 \000\000@\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\198\225\bE\130\141\252H\244\001\001\244\002\128\003\028\0067\bB,\020o\226G\160\b\015\160\020\000\024\224\001\136B\016 \001\024\018-\000\016\005\000\000\000\130\000\000\000\000\000\000\000\000\002\000\000\000\001\000\0010D\000`\000\007\001\000\006\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000@\000\000\000\003\027\132\001\022\n7\241#\208\004\007\208\n\000\012p\000\196 \b\136P\012\t<\128\000\002\128P\000c\000\006!\000D\002\128`I\228\000\000\020\002\128\003\024\0001\b\002 \020\003\002G \000\000\160\020\000\024\192BE.\224\250\015\133a\192\255\183\002\239M\1918x\012B\000\136\005\000\192\145\200\000\000(\005\000\0060\016\243\219\189\127\171\231\\\254\255\237\193\251\251o\255\190\000\000\000\000\000\000 \000P\000\000\000\000\000\000\000\003\027\132\001\022\n7\241#\208\004\007\208\n\000\012p\024\220 \b\176Q\191\137\030\128 >\128P\000c\129\015=\187\215\250\190u\207\239\254\220\031\191\182\255\249\224\000\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\000\000`\000\007\001\000\006\023\b\000\004\000\000\000\000\000\000\000\000\012\128\000\000\000\000\128\000\000\000@\000\000\000\000\024\000\001\192@\001\133\194\000\001\000\000\000\000\000\000\000\000\003 \000\000\000\000 \000\000\000\016\000\b\000\000\006\000\000p\016\000ap\128\000@\000\000\000\000\000\000\000\000\200\000\000\000\000\b\000\000\000\004\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196 \b\128P\012\t\028\128\000\002\128P\000c\001\015=\187\215\250\190u\207\239\254\220\031\191\182\255\251\224\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\004\000\000\000\000\000\192\001@\000\000\000\000\000\000\000\012n\016\004X(\223\196\143@\016\031@(\0001\192\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\"\151p}\007\194\176\224\127\203\129w\130\223\156<\198\225\000E\130\141\252H\244\001\001\244\002\128\003\028\by\237\222\191\213\243\174\127\127\246\224\253\253\183\255\207BE.\224\250\015\133a\192\255\183\002\239M\1918x\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\016\198\225\000E\130\141\252H\244\001\001\244\002\128\003\028\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\001\012n\016\004X(\223\196\143@\016\031@(\0001\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004$R\238\015\160\248V\028\015\249p.\240[\243\135\152\220 \b\176Q\191\137\030\128 >\128P\000c\129\t\020\187\131\232>\021\135\003\254\\\011\188\022\252\225\2307\b\002,\020o\226G\160\b\015\160\020\000\024\224BE.\224\250\015\133a\192\255\151\002\239\005\1918x\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\243\219\189\127\171\231\\\254\255\237\193\251\251o\255\158\132\138]\193\244\031\n\195\129\255n\005\222\155~p\243\027\132\001\022\n7\241#\208\004\007\208\n\000\012p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\207\245\187\199\234\191\253\207\247\255]\255\190\150\255\253\235\219\178 A\127\021 \000\1528\0298\224\176(41\184@\017`\163\127\018=\000@}\000\160\000\199\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000cp\128\"\193F\254$z\000\128\250\001@\001\142\004$R\238\015\160\248V\028\015\249p.\240[\243\135\152\220 \b\176Q\191\137\030\128 >\128P\000c\129\t\020\187\131\232>\021\135\003\254\\\011\188\022\252\225\2307\b\002,\020o\226G\160\b\015\160\020\000\024\224BE.\224\250\015\133a\192\255\151\002\239\005\1918y\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\016\145K\184>\131\225Xp?\229\192\187\193o\206\030cp\128\"\193F\254$z\000\128\250\001@\001\142\004$R\238\015\160\248V\028\015\249p.\240[\243\135\152\220 \b\176Q\191\137\030\128 >\128P\000c\129\t\020\187\131\232>\021\135\003\254\\\011\188\022\252\225\2307\b\002,\020o\226G\160\b\015\160\020\000\024\224BE.\224\250\015\133a\192\255\151\002\239\005\1918y\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\016\145K\184>\131\225Xp?\229\192\187\193o\206\030cp\128\"\193F\254$z\000\128\250\001@\001\142\004$R\238\015\160\248V\028\015\249p.\240[\243\135\152\220 \b\176Q\191\137\030\128 >\128P\000c\129\t\020\187\131\232>\021\135\003\254\\\011\188\022\252\225\2307\b\002,\020o\226G\160\b\015\160\020\000\024\224BE.\224\250\015\133a\192\255\151\002\239\005\1918y\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\016\145K\184>\131\225Xp?\229\192\187\193o\206\030cp\128\"\193F\254$z\000\128\250\001@\001\142\004$R\238\015\160\248V\028\015\249p.\240[\243\135\152\220 \b\176Q\191\137\030\128 >\128P\000c\129\t\020\187\131\232>\021\135\003\254\\\011\188\022\252\225\2307\b\002,\020o\226G\160\b\015\160\020\000\024\224BE.\224\250\015\133a\192\255\151\002\239\005\1918y\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\016\145K\184>\131\225Xp?\229\192\187\193o\206\030cp\128\"\193F\254$z\000\128\250\001@\001\142\004$R\238\015\160\248V\028\015\249p.\240[\243\135\152\220 \b\176Q\191\137\030\128 >\128P\000c\129\t\020\187\131\232>\021\135\003\254\\\011\188\022\252\225\2307\b\002,\020o\226G\160\b\015\160\020\000\024\224BE.\224\250\015\133a\192\255\151\002\239\005\1918y\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\016\145K\184>\131\225Xp?\229\192\187\193o\206\030\003\016\128 @\0020$\218\000 \n\000\000\001\004\000\024\132\001\002\000\017\129\"\208\001\000P\000\000\b \000\000\000\000\000\000\000\000 \000\000\000\016\000\019\004@\006\000\000p\016\000ap\128\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\004\000\000\000\0001\184@\017`\163\127\018=\000@}\000\160\000\199\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\b\000\t\002 cp\128\"\193F\254$z\000\128\250\001@\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196 \b\016\000\140\t\022\128\b\002\160\000\000A\000\000\000\000\000\000\000\000\001\000\000\000\000\128\000\144\"\0001\b\002\004\000#\002E\160\002\000\168\000\000\016@\000\000\000\000\000\000\000\000@\000\000\000 \000$\b\128\012B\000\129\000\b\192\145h\000\128*\000\000\004\016\000\000\000\000\000\000\000\000\016\000\000\000\b\000\t\002 \000\000\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\004\000\004\129\016\001\136@\016 \001\024\018-\000\016\005@\000\000\130\000\000\000\000\000\000\000\000\002\000\000\000\001\000\001 D\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128\017@\004\016\nC\000\003 \001\152\000\002\000E\237\217\016 \191\138\144\000L\028\014\156pX\020\026\025\252$Z\177U\191\153\158\128\160>\224P\001\227\128\006!\000@\128\004`H\180\000@\021\000\000\002\b\001\000\000\016\000\000\000\000\b\000\000\000\000\000\004\129\0161\184@\017`\163\127\018=\000@}\000\160\000\199\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000p\000@\004\000\000\000\016\000\000\000\000\000\000\000\000\001\000\000\000 \000\016\000\128\000\000\000\000\000\000\000\000\b\000\000\000\000\000\128\004\000\000\000\000\000\000\000\000\000@\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\t\000\"\128\b \020\134\000\004@\003\176\000\004\000\000\016\002\002\000\001\003\002\000\000\000\016\000\000\000\000\000B@\b\160\002\012\005!\192\001\016\000\204\000\001\000\000\018\000E\000\016@)\012\000\b\128\006`\000\b\000\000\144\002(\000\130!H`0d\0003\000 @\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\192\000\128\000\000\000\000 \000\000\000\000\000\000\000\000\006\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000 \000\002\000\000\012\004\000\128\000\000\128\128\000\000\004\000\000\000\000\000\000\144\002(\000\130\005Hp\000d\0003\000\000@\b\001\000 \000\0160 \000\000\001\000\000\000\000\000\004\000\000\000\000\000@\000\004\000\000\000\002\000\000\000\000\000\192@\b\000\000\b\b\000\000\000@\000\000\000\000\000\t\000\"\128\b T\135\000\006@\0030\000\004\000\128H\001\020\000A\000\1640\000\"\000\025\128\000 \004\002@\b\160\002\b\005!\000\001\016\000\204\000\001\000 \012\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\000@\000\004\000\000$\000\138\000 \128R\024\000\017\000\012\192\000\016\002\001 \004P\001\004\002\144\128\000\136\000f\000\000\128\016\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\004\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\b\000\000\128\000\004\128\017@\004\016\nC\000\002 \001\152\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000/n\200\129\005\252T\128\002`\224t\227\130\192\160\208\207\225\"\213\138\173\252\204\244\005\001\247\002\128\015\028\011\219\178 A\127\021 \000\1528\0298\224\176(43\248H\181b\171\1273=\001@}\192\160\003\199\000\012\004\000\128\128\000\128\130\000\000\004\000\000\000\000\000\000` \004\000\000\004\004\016\000\000 \000\000\000\000\000\003\001\000 \000\000 \000\000\001\000\000\000\000\000\000$\000\138\000 \129R\028\000\017\000\012\192\000\016\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\003\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000`\000\007\001\000\006\023\b\000\004\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\016\000\000\000\b\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000p\016\000ap\128\000@\000\000\000\000\000\000H\001\020\000A\016\1648\024\"\000\029\128\016 \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\144\018(\000\130\001H`\000D\0003\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\000\138\000 \128R\024\000\017\000\012\192\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\"\128\b\"\020\135\003\004@\003\176\002\004\000\000\017\000\000\002\000\002\000\012\000\000\000 \000\000\000\000\000\136\000\000\000\000\016\000`\000\000\001\000\000\000\000\000\004@\000\000\000\000\128\001\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000 \000\000\000\000\000\000\000\000\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\000H\001\020\000a\000\1648\000\"\000\029\128\000`\000\001\128\000\024\000\000\024\\(\000\016\000\000\000\000\000\000\000\000\000\000\000\128@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\192\000\014\002\000\012.\016\000\b\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000 \000\000\0000\000\003\128\128\003\011\132\000\002\000\000\000\000\000\000\000\000\004@\000\000\000\000@\000\001\000\000\000\000\000\128\000\000\"\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\001\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000 \016\000\128\000\000\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\128\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\016\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\024\000\001\128\000\001\133\194\000\001\000\000\000\000\000\000\001`\020P\001\006\006\144\224\000\200\000f\000@\132\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000X\005\020\000A\001\1648\0002\000\025\128\016!\004\000\136\000\000\000\000\016\000 \000\000\001\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000 \000\000\144\002(\000\130\001Hp\000D\0003\002\000B\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\001 \004P\001\004\002\144\224\000\136\000f\000\000\128\000\t\000\"\128\b \020\134\000\004@\0030\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\128\000\024\000\000\024\\(\000\016\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000@\000\000\000`\000\006\000\000\006\023\n\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\024\000\001\128\000\001\133\194\000\001\000\000\000\000\000\000\001`\004P\001\004\006\144\224\000\200\000f\000@\132\016\011\000\162\128\b04\135\000\006@\0030\002\004 \128\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\001\128\000\024\000\000\024\\ \000\016\000\000\000\000\000\000\022\000E\000\016@i\014\000\012\128\006`\004\bA\000\176\n(\000\131\003Hp\000d\0003\000 B\b\004\128\017@\004\016\nC\128\002 \001\152\000\002\000\000$\000\138\000 \128R\024\000\017\000\012\192\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000x\001\023\128\193\003\015\164\000\"\000\024\000\000 \000\001\128\000\t0A\024\000@\b\000\000\000\000\000\004\000\012\000\000I\002\b\192\002\000@\000\000\000\000\000 \000`\000\002H\016F\000\000\002\000\000\000\000\000\001\000\003\000\000\018@\0020\000\000\016\000\000\000\000\000\b\000\b\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\001 \004PA\004\000\016\192\000\128\000v\000D\128\016\006 \000x\016\000ap\160\000@\004\000@\000 \0000\000\019\128\128\003\011\132\000\002\000\000\000\000\001@\000\000\000\000\000\016\b\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\000\000\000\000\000\000\000\000\000\000\000\000\000,\128\138\000 \129R\026\000\017\000\028\192\b\016\002\001 \004P\001\132\002\144\224\000\136\000f\000A\132\016\t\000\"\128\b \020\135\000\004@\0030\002\004 \128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002@\b\160\002\b\005!\128\001\016\000\204\000\129\b \004@\000\000\000\000\128\001\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\000\138\000 \128\002\024\000\016\000\012\192\b\016\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\002@\b\160\002\b\005!\192\001\016\000\236\000\129\000 \004@\000\016\000\000\128\001@\000\000\b\000\128\000@\000\"\000\000\000\000\004\000\n\000\000\000@\004\000\002\000\000\000\000\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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@\b\160\003\b\005!\192\001\016\000\204\000\131\b \018\000E\000\016@)\014\000\b\128\006`\004\bA\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\002(\000\130\001H`\000D\0003\000 @\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000D\000\001\000\000\b\000\016\000\000\000\128\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\000\000\000\000\002\000\004\000\000\000 \000\000\001\000\002@\b\160\002\b\000!\128\001\000\000\204\000\001\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\t\000\"\130\b \000\134\000\004\000\003\176\002$\000\1281\000\003\192\128\003\011\133\000\002\000 \002\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\018\000E\000\016@\001\012\000\b\000\006`\004\b\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\138\000 \128R\024\000\017\000\012\192\b\016\002\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\017\000\000@\000\002\000\004\000\000\000 \000\000\001\000\000\136\000\000\000\000\016\000 \000\000\001\000\000\000\b\000\018\000E\000\016@\001\012\000\b\000\006`\000\b@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128\017@\004\016\000B\000\002\000\001\152\000\002\000\000\b\000\000\001\000\000\000\004\000\000\000\000\000\000\000@\000@\000\000\b\000\000\000 \000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002@\b\160\002\b\016!\128\001\000\000\204\b\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\016\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\138\000 \129\002\024\000\016\000\012\192\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\000\004\000@\000\000\001\000\000\000\000\000\000\000\000\000\016\000\000\002\000\001\000\b\000\000\000\000\000\000\000\000\000\128\000\000\000\000\b\000@\000\000\000\000\000\000\000\000\004\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\144\002(\000\130\000\b`\000@\000;\000\002@\000\001\000 \000\0160 \000\000\001\000\000\000\000\000\004$\000\138\000 \192\002\028\000\016\000\012\192\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\000\004\000\000\000\000\001\000\000\000\000\000\000\000\000\0000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000 \000\n\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\002(\000\130\004\b`\000@\0003\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\024\000\000\000\000\000\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\002\000@@\000 `@\000\000\002\000\000\000\000\000\bH\001\020\000A\128\0048\000 \000\025\128\000 \004\002@\b\160\002\b\000!\000\001\000\000\204\000\001\000 \012\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\000\000\000\000\004\000\000\b\001\001\000\000\129\129\000\000\000\b\000\000\000\000\000! \004P\001\006\000\016\224\000\128\000f\000\000\128\016\t\000\"\128\b \000\132\000\004\000\0030\000\004\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\001\000\000\016\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128\017@\004\016\000C\000\002\000\001\152\016\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\b\b\000\004\012\b\000\000\000@\000\000\000\000\001\t\000\"\128\b0\000\135\000\004\000\0030\000\004\000\000H\001\020\000A\000\0040\000 \000\025\128\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000 \0160 \128\000\001\000\000\000\000\000\000\b\001\001\000\000\129\129\004\000\000\b\000\000\000\000\000\000@\b\b\000\004\012\b\000\000\000@\000\000\000\000\001\t\000\"\128\b0\000\135\000\004\000\0030\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\136\000\000\016\000\016\000`\000\000\001\000\000\000\000\000\004@\000\000\000\000\128\003\000\000\000\b\000\000\000\000\000\"\000\000\000\000\004\000\b\000\000\000@\000\000\000\000\004\128\017@\006\016\000C\128\002\000\001\152\000\006\000\000D\000\000\001\000\000\128\006\000\000\000\000\000\000\000\000\002\000\000\000\b\000\004\0000\000\000\000\000\000\000\000\000\016\000\000\000\000\000 \001\128\000\000\000\000\000\000\000\000\128\000\000\000\000\001\000\004\000\000\000\000\000\000\000\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\002H\000@\000\000\002\000\000\000\000\000\001\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\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\016\000\002\000\016\001\"\004\000\000\000\000\000\000\000\000\002\000\000 \000\000\144!@@\000\000\004\000\128\000\000\016\000\001\000\000\004\129\b\002\000\000\000 \004\000\000\000`\000\007\001\000\006\023\b\000\004\000\000\000\000\000\000\000\000\004\000\000\000\000\000\128\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\016\000\000@\016\128 \000\000\002\000@\000\000\016\000\000\000\000@ \001\000\000\000\000\000\000\000\000\000\128\000\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\b\000\000\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\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\128\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\006\000\000p\016\000ap\128\000@\000\000\000\000\000\000@\000\004\000\000\016\0048\b\000\000\000\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\016\000\000@\002\000\000\000\000\000\000\000\000\001\000\000\000\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\016\000\000\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\004\000\000\000\000\000\000\000\000\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\002\000\000\012\000\000\224 \000\194\225\000\000\128\000\000\000\000\000\000\128\000\b\000\000 \b`\016\000\000\001\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\001\000\b\000\145\006\000\000\000\000\000\000\000\000\000@\000\b\000@\004\136\016\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\b\000\000\000\000\000\000\000\128\000\128\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\004\000\000\000\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\001\000\000 \001\000\018 @\000\000\000\000\000\000\000\000\024\000\001\192@\001\133\194\000\001\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\016\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\001\128\000\028\004\000\024\\ \000\016\000\000\000\000\000\000\000\000\004\000\000\000\000\002\000\000\000\000\000\001\000\000\000\000\000 \000\000\000\000\016\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\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 \005P\001\004B\144\224 \136\000v\000@\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\b\000\000\000\004\000\000\128\004\000H\129\000\000\000\000\000\000\000\000\000\144\002\168\000\130!Hp\016D\000;\000 @\b\004\000\000@\000\001\000C\128\128\000\000\b\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\192\000\014\002\000\012.0\000\b\000\000\000\000\000\000\006\000\000p\016\000ap\128\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\004\000\000\000\000\001\128\000\028\004\000\024\\ \000\016\000\000\000\000\000\000\016\000\001\000\000\004\001\014\006\000\000\000 \004\000\000\000\128\000\b\000\000 \b`\016\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\b\000\000\128\000\002\000\134\001\000\000\000\016\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\016\000\001\000\000\004\001\b\002\000\000\000 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128\017@\004\016\nC\128\002 \001\152\000\002\000@$\000\138\000 \128R\016\000\017\000\012\192\000\016\002\002\000\000\000\000\000\004\0000\000\000\000\000\000\000\000\000\016\000\000\000\000\000 \000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\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\004\000 \002D\b\000\000\000\000\000\000\000\000\004\128\017@\004\016\nC\128\002 \001\152\000\002\000@$\000\138\000 \128R\016\000\017\000\012\192\000\016\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\128\000\000\000\000\001\000\012\000\000\000\000\000\000\000\000\004\000\000\000\000\000\b\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\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\004\000\000\024\000\001\192H\001\149\194\000\001\000\000\000\000\000\000\001`\021P\001\006\004\016\224\000\136\000v\000\001\128\016\006\000\000`\000\000ap\128\000@\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\001\128\000\028\004\128\025\\ \000\016\000\000\000\000\000\000\012\000\000\224 \000\194\225\000\000\128\000\000\000\000P\000\000\000 \000\000\000\000\016\000\000\000\000\000\b\002\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\024\000\001\192H\001\149\194\000\001\000\000\000\000\000\000\000\192\000\012\000\000\012.\016\000\b\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\0000\000\003\128\144\003+\132\000\002\000\000\000\000\000\000\002\192*\160\002\012\b!\192\001\016\000\236\000\001\000 \022\001U\000\016`A\014\000\b\128\007`\000\b\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128\021@\004\016\000C\128\002\000\001\216\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\t\000\"\128\b \000\134\000\004\000\0030\000\004\000\128H\001\020\000A\000\004 \000 \000\025\128\000 \004\004\000\000\000\000\000\b\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\002\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\192\000\014\002@\012\174\016\000\b\000\000\000\000\000\000\t\000\"\128\b \000\134\000\004\000\0030\000\004\000\128H\001\020\000A\000\004 \000 \000\025\128\000 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128\017@\004\016\000B\000\002\000\001\152\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128\017@\004\016\000C\000\002\000\001\152\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \004P\001\004\000\016\128\000\128\000f\000\000\128\016\004\000\000$\128\004`\001\000 \000\000\000\000\000\016\000 \000\001$\000#\000\000\001\000\000\000\000\000\000\128\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\018\000E\000\016@)\012\000\b\128\007`\004\b\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128\017@\004\016\nC\000\002 \001\152\001\002\000@$\000\138\000 \128R\016\000\017\000\012\192\000\016\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\000H\001\020\000A\000\004 \000 \000\025\128\000 \004\001\000\000\t \001\024\000@\b\000\000\000\000\000\004\000\b\000\000I\000\b\192\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\016\000\000\024\128\001\224@\001\133\194\128\001\000\016\001\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\"\128\b \000\134\000\004\000\0030\002\004\000\128H\001\020\000A\000\004 \000 \000\025\128\000 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\b\000\000\000\000\000\000\000\000\004@\000\000\016\000\b\000`\000\000\000\000\000\000\000\000 \000\000\000\000\000@\003\000\000\000\000\000\000\000\000\001\000\000\000\000\000\002\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\197 \n\018\000\140\t\021\128\b\002\144\000\001A\000\002\000\000@\002\000d@\128\000\000\128\000\000\000\000\000@\000\004\000\000\018\004(\024\000\000\000\128\016\000\000\002\000\000 \000\000\144!\000\192\000\000\004\000\128\000\000\016\000\001\000\000\004\001\b\006\000\000\000 \004\000\000\001\000\000\000\000\004\002\000\016\000\000\000\000\000\000\001\000\000\000\000\000\000 \016\000\128\000\000\000\000\000\000\000\000\000\000\000\000\001\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000H\000\0067\b\002,\020o\226G\160\b\015\160\020\000\024\224\000\000\000\000\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\012n\016\004X(\223\196\143@\016\031@(\0001\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\002\000\000\b\002\024\012\000\000\000@\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000@ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\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\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\192\000\014\002\000\012.\016\000\b\000\000\000\000\000\000\b\000\000\128\000\002\000\135\003\000\000\000\016\002\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\018\000\001\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\000\000\000\000\000\000\000\000\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\027\132\001\022\n7\241#\208\004\007\208\n\000\012p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\b\000\000 \001\000\000\000\000\000\000\000\016\000\000\000\000@\000\001\000\b\000\000\000\000\000\000\000\000\000\000\000\002\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000b\144\005\t\000F\004\138\192\004\001H\000\000\160\128\003\128\0008\b\0000\184@\000 \000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\006\000\000p\016\000ap\128\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\004\000\000\000\0001\184@\017`\163\127\018=\000@}\000\160\000\199\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000cp\128\"\193F\254$z\000\128\250\001@\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0001H\002\132\128#\002E`\002\000\164\000\002P@\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\001\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\016\000\000@\016\192`\000\000\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000@\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\b\000\000\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\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\128\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\006\000\000p\016\000ap\128\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\012R\000\161 \b\192\145X\000\128)\000\000\020\016\000p\000\007\001\000\006\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\192\000\014\002\000\012.\016\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\128\000\000\000\0067\b\002,\020o\226G\160\b\015\160\020\000\024\224\000\000\000\000\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\012n\016\004X(\223\196\143@\016\031@(\0001\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\024\220 \b\176Q\191\137>\128 >\128P\000c\128\198\225\000E\130\141\252H\244\001\001\244\002\128\003\028\000@\000\004\000\000\016\0040\024\000\000\000\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\128\004\000\200\131\000\000\001\000\000\000\000 \000 \000\004\000 \006D\024\000\000\b\000\000\000\000\000\001\000\000 \001\0002 @\000\000@\000\000\000\000\000\b\000\001\000\b\001\145\002\000\000\002\000\000\000\000\000\000\196 \136\025\000\140\t6\128\b\002\128\000\000A\001{vD\b/\226\164\000\019\007\003\167\028\022\005\006\1281\b\"\004\000#\002M\160\002\000\160\000\000\016@\001\136A\016 \001\024\018-\000\016\005\000\000\000\130\000\012B\000\129\000\b\192\145h\000\128(\000\000\004\016\000\000\000\000\000\000\000\000 \000 \000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\004\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\016\000\000\001\000\000\000\000\128\000\016\000\128\025\016 \000\000 \000\000\000\000\000\012\000\000\224 \000\194\225\000\000\128\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\b\000\000\001\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197 \n\018\000\140\t5\128\b\002\128\000\000A\000\006)\000P\144\004`H\172\000@\020\000\000\002\b\0001H\002\132\128\163\002E`\002\000\160\000\000\016@\000\128\000\016\000\128\025\016 \000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\001\000 \000\004\000 \006D\b\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000<\164\171Pj\137\211?\188\017\000\\\202\b\128P\000c\128\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\0001\184@\017`\163\127\018=\000@}\000\160\000\199\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\144\000\000\000\000\000\000\000\000\001\000\002\128\000\000\000\000\000\000\000\024\220 \b\176Q\191\137\030\128 >\128P\000c\128\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000&\192\248\003\000@@>\001\000 \000,0\025\141\194\022\139\005\027\248\145\232\002\003\232\005\000\0078\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000cp\128\"\193F\254$z\000\128\250\001@\001\142\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\198\225\000E\130\141\252H\244\001\001\244\002\128\003\028\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\n\000\000\000\000\000\000\000\000cp\128\"\193F\254$z\000\128\250\001@\001\142\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000!\231\183z\255W\206\249\253\255\219\131\247\246\223\255<\198\225\000E\130\141\252H\244\001\001\244\002\128\003\028\bH\165\220\031A\240\1728\031\242\224]\224\183\231\0151\184@\017`\163\127\018=\000@}\000\160\000\199\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\016\243\219\189\127\171\231|\254\255\237\193\251\251o\255\158cp\128\"\193F\254$z\000\128\250\001@\001\142\004$R\238\015\160\248V\028\015\249p.\240[\243\135\152\220 \b\176Q\191\137\030\128 >\128P\000c\128\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\by\237\222\191\213\243\190\127\127\246\224\253\253\183\255\2071\184@\017`\163\127\018=\000@}\000\160\000\199\002\018)w\007\208|+\014\007\252\184\023x-\249\195\192 \000\000\000\000\006\000\n\000\000\000\000\000\000\000\000cp\128\"\193F\254$z\000\128\250\001@\001\142\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000!\231\183z\255W\206\249\253\255\219\131\247\246\223\255<\198\225\000E\130\141\252H\244\001\001\244\002\128\003\028\bH\165\220\031A\240\1728\031\242\224]\224\183\231\0151\184@\017`\163\127\018=\000@}\000\160\000\199\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\016\243\219\189\127\171\231|\254\255\237\193\251\251o\255\158cp\128\"\193F\254$z\000\128\250\001@\001\142\004$R\238\015\160\248V\028\015\249p.\240[\243\135\152\220 \b\176Q\191\137\030\128 >\128P\000c\128\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\by\237\222\191\213\243\190\127\127\246\224\253\253\183\255\2071\184@\017`\163\127\018=\000@}\000\160\000\199\002\018)w\007\208|+\014\007\252\184\023x-\249\195\192\000\000\000\000\000\000\000\000\000\000\000\000\018\000\000\000\000\000\000\000\000\000 \000P\000\000\000\000\000\000\000\003\027\132\001\022\n7\241#\208\004\007\208\n\000\012p\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\001\015=\187\215\250\190w\207\239\254\220\031\191\182\255\249\2307\b\002,\020o\226G\160\b\015\160\020\000\024\224BE.\224\250\015\133a\192\255\151\002\239\005\1918y\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\135\158\221\235\253_;\231\247\255n\015\223\219\127\252\243\027\132\001\022\n7\241#\208\004\007\208\n\000\012p!\"\151p}\007\194\176\224\127\203\129w\130\223\156<\198\225\000E\130\141\252H\244\001\001\244\002\128\003\028\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000C\207n\245\254\175\157\243\251\255\183\007\239\237\191\254y\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\016\145K\184>\131\225Xp?\229\192\187\193o\206\030\135\158\221\235\253_;\231\247\255n\015\223\219\127\252\243\027\132\001\022\n7\241#\208\004\007\208\n\000\012p!\"\151p}\007\194\176\224\127\203\129w\130\223\156=\015=\187\215\250\190u\207\239\254\\\031\190\150\255\249\224\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\012n\016\004X(\223\196\143@\016\031@(\0001\192\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\024\220 \b\176Q\191\137\030\128 >\128P\000c\128\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\002\000\000\000\001\000\001 D\012n\016\004X(\223\196\143@\016\031@(\0001\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\004\024\220 \b\176Q\191\137\030\128 >\128P\000c\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0001\b\002\004\000#\002E\160\002\000\160\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000b\016\132@(\006\004\142@\000\001@(\0001\128\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\024\220 \b\176Q\191\137\030\128 >\128P\000s\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\141\194\004\139\005\027\248\145\232\002\003\232\005\000\0068\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\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\136@\017\000\160\024\0189\000\000\005\000\160\000\198\002\000\000\000\000\000\000\000\000\000\001\128\000\002@\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\000D\000\000\000\000\000\000\000\000\002\000\001 \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\128\000\000\000\000\000\000\136\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000@\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\024\000\000$\000\000\000\002\000\000\000\000\000`\b\224\000\000\000\000\000\000\000\b\000\000\136\000\000\000\000\000\000\006\000\004\t\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\b\000\000\000\000\000\000\000\000\000\000\000\000\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\027\132\001\022\n7\241#\208\004\007\208\n\000\012p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\198\225\000E\130\141\252H\244\001\001\244\002\128\003\028\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\012n\016\004X(\223\196\143@\016\031@(\0001\192\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\024\220 \b\176Q\191\137\030\128 >\128P\000c\128\000\016\000\000\000\000\000\000\000\000\000\000\004\000\000\000\0067\b\002,\020o\226G\160\b\015\160\020\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\001\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\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\2281\b\252\005\141)\022\159\024\130\176 \006K,\000\000\000\000\000\000 \000\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\138@\020$\005\024\018+\000\016\005\000\000\002\130\000\012\000\000\192\000\000\194\225\000\000\128\000\000\000\000\000\000 \000\000\000\001\002\000\000\000\004\000\000\000\000\000\000cp\128\"\193F\254$z\000\128\250\001@\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\197 \n\018\002\140\t\021\128\b\002\128\000\001A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012R\000\161 (\192\145X\000\128(\000\000\020\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\003\027\132\001\022\n7\241#\208\004\007\208\n\000\012p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\198\225\000E\130\141\252H\244\001\001\244\002\160\003\028\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\145K\184>\131\225Xp?\229\192\187\193o\206\030\003\016\128 @\0020$Z\000 \n\128\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0067\b\002,\020o\226G\160\b\015\160\020\000\024\224BE.\224\250\015\133a\192\255\151\002\239\005\1918y\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\016\145K\184>\131\225Xp?\229\192\187\193o\206\030\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\t\020\187\131\232>\021\135\003\254\220\011\1896\252\225\224\000\004\000\031\000`\b\b\007\192`\004\000\005\130\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\030{w\175\245|\235\159\223\253\184?\127m\255\247\192\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002D\015\1280\004\004\003\224P\002\000\002\193\001\128\000\002\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \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\006\002\000@\000\000@A\000\000\002\000\000\000\000\000\0000\016\002\000\000\002\002\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\016\000@\000\128\000\000\000\000\000\001\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000\000 \000\000\000\128\000\000\000\000\000\000\000\000\024\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\128\000\b\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\0001\184@\017`\163\127\018=\000@}\000\160\000\199\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\"\000\000\004\000\004\000\024\000\000\000@\000\000\000\000\001\016\000\000\000\000 \000\192\000\000\002\000\000\000\000\000\b\128\000\000\000\001\000\002\000\000\000\016\000\000\000\000\000\000\000\000\000\128\000\000 \000@\000\000\000\001\000\000\000\000\000\000\000\000\000\001\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\0001\184@\017`\163\127\018=\000@}\000\160\000\199\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\000\000\224 \000\194\225\000\000\128\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\016\000\000\000\024\000\001\192@\001\133\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\016\000\000\000\000\198\225\000E\130\141\252H\244\001\001\244\002\128\003\028\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\b\000\000\000\012\000\000\224 \000\194\225\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\b\000\000\000\000cp\128\"\193F\254$z\000\128\250\001@\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\198\225\000E\130\141\252H\244\001\001\244\002\128\003\028\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\018\000E\000\016@)\012\000\012\128\006`\000\b\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\138]\193\244\031\n\195\129\255.\005\222\011~p\240\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\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\128\128\016\016\000\016\016@\000\000\128\000\000\000\000\000\012\004\000\128\000\000\128\130\000\000\004\000\000\000\000\000\000` \004\000\000\004\004\000\000\000 \000\000\000\000\000\000\000\004\000\000\000 \000\128\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\b\b\000\004\012\b\000\000\000@\000\000\000\000\001\000\000\b\000\000\016\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\002\000\000\000\000\000\000\000\000\000\000\000\018\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196 \b\016\000\140\t\022\128\b\002\160\000\000E\001\t\020\187\131\232>\021\135\003\254\\\011\188\022\252\225\232\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\136@\016 \001\024\018-\000\016\005@\000\000\138\002\018)w\007\208|+\014\007\252\184\023x-\249\195\192\000\b\128>\000\192\016\016\015\128@\b\000\015\132\006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\001\001\000\000\129\129\000\000\000\b\000\000\000\000\000 \000\001\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\016\002\002\000\001\003\002\000\000\000\016\000\000\000\000\000@\000\002\000\000\004\000\000@\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \004\004\000\002\006\004\000\000\000 \000\000\000\000\000\128\000\004\000\000\b\000\000\128\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 \004P\001\004\n\144\224\000\136\000f\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\016\002\000\000\002\002\b\000\000\016\000\000\000\000\000\001\128\128\016\000\000\016\016\000\000\000\128\000\000\000\000\000\018\000E\000\016@\169\014\000\b\128\006`\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128\017@\004\016\nC\000\002\000\001\152\000\002\000\000$\000\138\000 \128R\016\000\016\000\012\192\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\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\b\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000@\000\000\000\000\000\003\000\0000\000\0000\184\192\000\"\000\000 \000\000\000\024\000\001\128\000\001\133\194\000\001\016\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\016\000\128\000\000\001\000\000\000\002 \000\000\000\000\000\001\128\000\024\000\000\024\\ \000\017\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\002\000\000\000\000\000\000\000\000\000\000\000\006\000\000p\016\000ap\128\000@\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\004\000\000\000\000\000@\000\000\000\128\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\000\000\000\000\000\000\000\000\000\000\192\000\014\002\000\012.\016\000\b\000\000\000\000\000\000\000\000\b\000\000\000\000\001\000\000\000\000\000\000\128\000\000\000\000@\000\000\000\000\b\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\000\224 \000\194\225\000\000\128\000\000\000\000\000\000\000\000\128\000\000\000\000\016\000\000\000\000\000\b\000\000\000\000\000\000\000 \016\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000H\001\020\000A\000\1648\000\"\000\025\128\016 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\016\000\004\000\000 \000@\000\000\002\000\000\000\016\000\b\128\000\000\000\001\000\002\000\000\000\016\000\000\000\128\000D\000\000\000\000\b\000\016\000\000\000\128\000\000\000\000\t\000\"\128\012 \020\135\000\004@\003\176\000\012 \000\017\000\000\000\000\002\000\004\000\000\000 \000\000\000\000\002@\b\160\002\b\005!\192\001\016\000\204\000\001\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\002(\000\130\001H`\000D\0003\000\000B\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\002(\000\194\001Hp\000D\000;\000\000\194\000\001\016\000\000\000\000 \000@\000\000\002\000\000\000\000\000$\000\138\000 \128R\028\000\017\000\012\192\000\016\128\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\000H\001\020\016A\000\1640\000\"\000\029\128\016 \004\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\004@\000\016\000\000\128\001\000\000\000\b\000\000\000@\000\"\000\000\000\000\004\000\b\000\000\000@\000\000\002\000\004\128\017@\004\016\nC\000\002 \001\152\000\002\016\000\000\000\000\000\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\bH\001T\000A\130\1648\000\"\000\029\128\002 \004@\000\002\000\000\004\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\002(\000\130\001H`\000D\0003\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\b\000\000\016\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\002\000\000\000\000\000@\000\000\000\000\000&\b\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000`\000\007\001\000\006\023\b\000\004\000\000\000\000\000\000\000\000\004\000\000\000\000\000\128\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\016\000\000@\016\128`\000\000\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012B\000\129\000\b\192\145h\000\128*\000\000\004P\016\145K\184>\131\225Xp?\229\192\187\193o\206\030\132\138]\193\244\031\n\195\129\255.\005\222\011~p\240\024\132\001\002\000\017\129\"\208\001\000T\000\000\b\160!\"\151p}\007\194\176\224\127\203\129w\130\223\156<\198\225\000E\130\141\252H\244\001\001\244\002\128\003\028\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0001\184@\017`\163\127\018=\000@}\000\160\000\199\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000cp\128\"\193F\254$z\000\128\250\001@\001\142\000\000\000\000\000\000\000\000\000\000\000\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\0001\184@\017`\163\127\018=\000@}\000\160\000\199\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\012n\016\004X(\223\196\143@\016\031@(\0001\192\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\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@\b \002\b\000!\000\001\000\000\200\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\b\128\000\000\000\001\128\002\000\000\000\016\000\000\000\000\000\000\017\000\252\001\129 \000\031\016\128\016 \006\n,\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\002\000\000\000\001\000\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\002\000\031\1280$\000\003\226\016\002\004\000\193E\128\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\128\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\128\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000`\000\007\001\000\006\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\198\225\000E\130\141\252H\244\001\001\244\002\128\003\028\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\001\000\000\000\000\000\000\128\128\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\000\000\000\000\000\000\000\000\000\000\b\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000` \004\000\000\004\004\000\000\000 \000\000\000\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\004\000\000\000\000\128\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\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\004\000\000@\000\000\000\b\000\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\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006!\000@\128\004`H\180\000@\021\000\000\002\b\000\000\000\000\000\000\000\000\b\000\000\000\001\000\004\129\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\016\000\000\000\000\003\000\000\000\000\000\000\000\000\000\0003\248H1b\171\1273=\001P}\200\160\001\199\000\004\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\178\018\b\000\130\007H@@D\000r\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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@\b \002\b\005!\000\001\016\000\200\b\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\016\000\000\000\000\000\000\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 \004\016\001\004\002\144\128\000\128\000`\000\000\128\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\016\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\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\003?\132\131\022*\183\2433\208\021\007\220\138\000\028p\025\252$\024\177U\191\153\158\128\168>\228P\000\227\128\t\000 \128\b \020\132\000\004@\003 \000\004\000\000H\001\004\000A\000\164 \000\"\000\025\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\002\b\000\130\001H`\000D\0002\000\000@\000\004\128\016@\004\016\nB\000\002 \001\144\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\000H\001\004\000A\000\1640\000\"\000\025\000\000 \000\002@\b \002\b\005!\000\001\016\000\200\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\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000") + (127, "'\225 \197\138\173\2433\208\020\007\242(\000q\192F\194\000\139\133\027\226O\160\b\015\128P\000c\129\247\217\016 \191\141@\0010p=\199\005\129A\160\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\250\217\189f\235\252\205\255%C\252J\136<\240>\251\"\004\023\241\168\000&\014\007\184\224\176(4\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\141\132\001\022\n7\196\159@\016\031\000\160\000\199\003\239\178 A\127\026\128\002`\224{\142\011\002\131B~\018-X\170\2233=\001@\127\002\128\015\028\000\000\000\000\b\000\024\000\128\000\000\000\000\000\000\000\000\000\000\000\000\0000\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\128\007\224\012$\000\003\226\016\b\016\002\005\022\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\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\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\000\000\000\000\000\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\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\b\128\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\016\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000`\000\014\002\000\024\184@\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000X\011:\000\131%!\192\193\145\003\176\"D\"\128\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\224 A\139\132\000\002\000\000\000\000\000\000\004\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\016\004\004\004\002\012\016@\000\000\128\000\000\000\000\000 \b\b\000\004\024 \128\000\001\000\000\000\000\000\000@\016\016\000\b0@\000\000\002\000\000\000\000\000\"@\021@\004\024I\014\000\b\128\029\129\003 \004\004\128 \128\b \002\020\000\016\0001\000\000@\000\t\000A\000\016@\004 \000 \000b\000\000\128\000\012\000\000\147\004\019\000\016\002\000\000\000\000\000\004\000\024\000\001$\b&\000 \004\000\000\000\000\000\b\0000\000\002H\016L\000\000\b\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\b\000\000\000\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\000$\128\004\192\000\000\128\000\000\000\000\001\000\004\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\016\000\001$\000 \000\000\004\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\004\016\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\004\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\002\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\002\000\000$\128\004\000\000\000\128\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000$\001\020\016A\000\016\192\000\128\001\216\001\018\000@2\000\007\129\000\012\\(\000\016\004\000@\000 \000\144\004P\001\132\018C\128\002 \006`D\024A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\144\0008\b\000b\225@\000\128 \002\000\001\000\003\000\bp\016 \197\194\000\001\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\022\002\238\000 \201Hp0D@\236\000\179\b\176\024\000\003\000\000\006.\016\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000`\000\012\000\000\024\184@\000\"\000\000\128\000\000\000@\004\000\000\000\016\000\000\000D\000\000\000 \000\001\128\0008\b\000b\225\000\000\128\000\000\000\000\000}\246D\b/\227P\000L\028\015q\193`PhO\194E\171\021[\230g\160(\015\224P\001\227\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\002L\016L\000@\b\000\000\000\000\000\016\000`\000\004\144 \152\000\128\016\000\000\000\000\000 \000\192\000\t A0\000\000 \000\000\000\000\000@\001\128\000\018@\002`\000\000@\000\000\000\000\000\128\001\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\t\000E\004\016@$0\000\"\000v\000@\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\001\020\000A\000\144\192\000\136\001\152\001\002\000G\223d@\130\2545\000\004\193\192\247\028\022\005\006\132\252$Z\177U\190fz\002\128\254\005\000\0308\b\216@\017p\163|I\244\001\001\240\n\000\012p\017\176\128\"\193F\248\147\232\002\003\224\020\000\024\224#a\000E\130\141\241#\208\004\007\192(\0001\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\132\001\016\n\003\004\142@\000\003\000\160\000\198\000 \000\004\002\000\020\016\160`\000\000\b\001\000\000\000@\000\b\000\000(!@\192\000\000\016\002\000\000\000\128\000\016\000\000PB\001\128\000\000 \004\000\000\000\200@\016 \0010H\180\000@4\000\000\b \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200b\017\248\0119H\180\248\1966\004\000\201e\128\000\004\000\000\000\000\000\b\000\000@\000\000\000\000\003\000\000\000@\000\000\004\000\000\000\000\000\000\000\000\006\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128 \000\016`\128\000\000\004\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\012\b\001\000\000\002\004\016\000\000 \000\000\000\000\000\024\016\002\000\000\004\b\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\252$\024\177U\190f\250\002\128\254%\000\0148\t\248H1b\171|\204\244\005\001\252J\000\028p\019\240\145b\197V\249\153\232\n\003\249\148\0008\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\024\016\002\002\000\004\b \000\000@\000\000\000\b\0000 \004\004\000\b\016@\000\000\128\000\000\000\000\000`@\b\000\000\016 \128\000\001\000\000\000\000\000\000\192\128\016\000\000 @\000\000\002\000\000\000\000\000\003\129\000 \000\000@\128\000\000\004\000\000\000\000\000#a\000E\130\141\241'\208\004\007\192(\0001\192F\194\000\139\005\027\226G\160\b\015\128P\000c\128\004\000\000\001\000\001\000\016\000\000\000\000\000\000\000\000\b\000\000\000\000\002\000 \000\000\000\000\000\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\128\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\253n\255\179}\254\255\255\147\163\254e\132\014y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000F\194\000\139\133\027\226O\160\b\015\128P\000c\128\141\132\001\022\n7\196\159@\016\031\000\160\000\199\001\027\b\002,\020o\137\030\128 >\001@\001\142\0026\024\132~*\223R=>a|\131\1283]`d!\b\128P\024$r\000\000\024\005\000\0060\b\216@\017`\163|H\244\001\001\240\n\000\014p#\222\221\235\253_o\159\223\253\184}\253\183\255\207#a\000E\130\141\241#\208\004\007\192(\0001\192\006B\000\129\000\t\130E\160\002\001\128\000\000A\000\012\132\001\002\000\019\004\139@\004\003@\000\000\162\000\025\b\018\004\000&\t\022\128\b\006\128\000\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\"\000\000\000\000\000\000\000\000\016\000\001\000\000\012\000\001\192@\003\023\b\000\004\000\000\000\000\000\000\024\000\003\128\128\006.\016\000\b\000\000\000\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000`\000\014\002\000\024\184@\000 \000\000\000\000\016\000\192\000\156\004\0001p\128\000@\000\000\000\000\160\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\128\006\000\000\224 \001\139\132\000\002\000\000\000\000\005\000\004\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\016\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\016\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\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\192\000\028\004\0001p\128\000@\000\000\000\000 \000\128\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\018\000\238\000 \200Hp0D@\236\000\177\b\176\024\000\003\128\128\006.\016\000\b\000\000\000\000\000\004H\011\184\000\131!!\192\193\017\003\176\002\196\"\192`\000\012\000\000\024\184@\000 \000\000\000\000\000\000\000\000\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\001\000\000\000\000\000\192\194\000\000\000\000\000\000\000\000\006\000\000\224 A\139\132\000\002\000\000\000\000\000\000\012\000\001\128\000\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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,\005\220\000A\146\144\224`\136\129\216\001b\017`0\000\006\000\000\012\\ \000\016\000\000\000\000\000\b\176\023p\001\006JC\129\130\"\007`\005\136E\128@\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\144\007p\001\006BC\129\130\"\007`\005\136E\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\022\002\238\000 \201Hp0D@\236\000\177\b\176\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\016\000\000\016\000\000@\000\000\000\b\000\024\000\003\128\128\006.\016\000\b\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000`\000\014\002\000\024\184@\000 \000\000\000\000\000\000\000\000\128\000\000\000\001\000\000\004\000\000\000\000\129\001\128\0008\b\000b\225\000\000\128\000\000\000\000\000\000\000\002\000\000\000\000\004\000\000\016\000\000\000\002$\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\016\000\000@\000\000\000\b\144\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\001\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\128\000\000\004\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\016\000\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\000@\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\016\000\000\000\000@\000\000\000\128\000\000\000\000\000\002 \000\000\000\000\000\000\000\001\000\000\000\000\000\200@\016 \0010H\180\000@4\000\000\b \001\144\128 `\002`\147H\000\128`\000\000\016@\003!\000@\128\004\193&\144\001\000\192\000\000 \128\006B\000\129\000\t\130E \002\001\128\000\000A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e#j\018\002\152$\214\000 \025@\129\181T\000\000@\000 \001\000\000\004\000\000 \000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000L\164mB@S\004\155\192\004\003h\b6\170\128\b\000\000\000\000\004\001\020\000\000\000\000\000\000\000\0002\016\132\b\000L\018-\000\016\r\000\000\018\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200@\0160\0010I\180\000@4\000\000\b \001\144\128 @\002`\147h\000\128h\000\000\016@\003!\000@\128\004\193\"\208\001\000\208\000\000 \128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\216\000\000\128\000 \000\000\000P\000LQ\0002\016\004\b\000L\018-\000\016\r\000\000\002\b\002\000\003`\000\002\000\000\128\000\000\001@\0011D\000\200@\016 \0010H\180\000@4\000\000\b \b\000\r\128\000\b\000\002\000\000\000\005\000\004\197\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000&B6\129\000)\130M\160\002\001\180\000\019U@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0012\017\180\b\001L\018m\000\016\r\160\000\154\170\000t1\b\252\005\156\164Z|b\027\002\000d\178\192\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\004\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\016\000\000\000\000\000\000\000\000\000\000\000\000\000\012\132\001\002\000\019\004\138@\004\003\000\000\000\130\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\004\000\000 \000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\b\000\000\000\000\000\019\004@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\025\b\002\004\000&\t\022\128\b\006\128\000\001\004\001\000\001\176\000\001\000\000@\000\000\000\160\000\152\162\000`\000\014\002\000\024\184@\000 \000\000\000\000\000\000\000\002\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\003!\000@\128\004\193\"\208\001\000\208\000\000 \128 \0006\000\000 \000\b\000\000\000\020\000\019\020@\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\000\000\000\000\000\000\000\000\000\000\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\b\000\000\000\000\004\000\000\000\000\000\t\002 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\132\t\002\000\019\004\139@\004\003@\000\000\130\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128\000\000\000\001\000\000\000\000\000\002B\136\001\144\129 @\002`\145h\000\128h\000\000\020@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000D\000\000\000\000\016\000\000\000\000\000$\b\128\000\000\136\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\016\000\000\004\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0002\144\005\t\000L\018k\000\144\012\128\000\154+\000\000\000\000\000\000\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\004\000\000@\000\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\016\000\000\000\000\b\000\000\000\016\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\004\000\000\000\000#a\000E\130\141\241#\208\004\007\192(\0001\192\006B\b\129\144I\130M\160\002\001\160\000\000A\000\012\b\001\001\000\002\004\016\000\000 \000\000\000\004\000\024\016\002\002\000\004\b \000\000@\000\000\000\000\0000 \004\000\000\b\016@\000\000\128\000\000\000\000\000`@\b\000\000\016 \000\000\001\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\003\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\b\002\002\000\001\006\b\000\000\000@\000\000\000\000\000\016\004\132\000\002\012\016\000\000\000\128\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000@\016\016\000\b0@\000\000\002\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\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\016\004\004\000\002\012\016\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017 \n\160\002\012\004\135\000\004@\014\192\001\016\002\000@\000\000\000\016\000\000\000\000\000\000\000\000\000\000\003\000\000$\128\004\192\000\000\128\000\000\000\000\001\000\002\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\b\000\000\024\000\003\192\128\006.\016\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000`\000\014\002\000\024\184@\000 \000\000\000\000\000\017 \n\160\002\012\004\135\000\004@\014\192\001\016\n\001\128\0008\b\000b\225\000\000\128\000\000\000\000\000D\128*\128\b0\018\028\000\017\000;\000$@(\137\000U\000\016`$8\000\"\000v\000H\128\016\012\000\001\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000@\000\000\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\b\144\005P\001\006\002C\128\002 \007`\004\136\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\192\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\016\000\004\000\000\004\001\001\000\000\131\004\000\000\000 \000\000\000\000\002$\001T\000A\128\144\224\000\136\001\216\000\"\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000@\000\000\000@\000\000\000\000\016\000\000\000\000\000\000\000\000\000\"@\021@\004\024I\014\000\b\128\029\129\003 \004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\004\004\000\002\012\016\000\000\000\128\000\000\000\000\b\144\005P\001\006\002C\128\002 \007`\000\136\001\000@\016\016\000\b0@\000\000\002\000\000\000\000\000\"@\021@\004\024\t\014\000\b\128\029\128\002 \004\000\000\000\000\000\000\000\000\000\000\000\b\002\002\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\018\000\170\000 \194Hp\000D\000\236\b\017\000 \b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\144\005P\001\006\018C\128\002 \007`@\136\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\"@\021@\004\024\t\014\000\b\128\029\128\002 \004\000\128\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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$\001T\000A\128\144\224\000\136\001\216\000\"\000D\000\000\128\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\016\000\002\000\000\004\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\016\000\000\000\000\000\000\000\000\000\000\006\004\000\128\000\001\002\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002$\001T\000A\132\144\224\000\200\001\216\000&\000@p \132\000\000\b\016\000\000\000\128\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 \001\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 \193\000\000\000\b\000\000\000\000\000\128\000\016\000\000 \000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\144\005P\001\006\018C\128\003 \007`@\152\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\002\000\004\000\000\000\000\000\000#a\000E\130\141\241#\208\004\007\192(\0001\192F\194\004\139\005\027\226G\160\b\015\128P\000c\128\000\000\000\000\000\001\000\000\000\001\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\002\000@\000\000\000\0026\016\004X(\223\018=\000@|\002\128\003\028\000d \b\128P\024$r\000\000\024\005\000\0060\016\000\004@\000\000\000\000\000\000\192\002\004\129 \000\001\144\128\"\001@`\145\200\000\000`\020\000\024\192#a\000E\130\141\241#\208\004\007\192(\0001\192\006B\000\136\133\001\130O \000\001\128P\000c\000\012\132\001\016\n\003\004\158@\000\003\000\160\000\198\000\025\b\002 \020\006\t\028\128\000\006\001@\001\140\0026\016\004\\(\223\018}\000@|\018\128\003\028\004l \b\176Q\190$\250\000\128\248%\000\0068\b\216@\017`\163|H\244\001\001\240J\000\012p\017\176\128\"\225F\248\147\232\002\003\224\020\000\024\224#a\000E\130\141\241'\208\004\007\192(\0001\192F\194\000\139\005\027\226G\160\b\015\128P\000c\128\012\132\001\003\000\019\004\155@\004\003@\000\000\138\000\025\b\002\004\000&\t6\128\b\006\128\000\001\020\0002\016\004\b\000L\018-\000\016\r\000\000\002(\000d \b\016\000\152$Z\000 \026\000\000\004\016\004\000\000\000\000\004\000\001\000\000\000\000\000\002@\136\017\176\128\"\193F\248\145\232\002\003\224\020\000\024\224\003)\000P\208\004\193&\176\001\000\192\000\000 \128\006R\000\161 \t\130M`\002\001\128\000\000A\000\012\164\001B@\019\004\138\192\004\003\000\000\000\130\000\016\000\000\000\000\006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000d \b\016\000\152$Z\000 \026\000\000\004\016\000\000\002\000\000\000\000\001\000\000\000\002\000\002`\136\001\128\0008\b\000b\225\000\000\128\000\000\000\000\000\000\000\b\000\000\000\000\004\000\000\000\b\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\232b\017\248\0119H\180\248\1966\004\000\201e\128\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\132\001\002\000\019\004\138@\004\003\000\000\000\130\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000e \n\018\002\152$V\000 \025\000\000\148\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\128\000\006\000\000\192\000\001\139\132\000\002\000\000\000\000\000\000\004\000\000\000\000A\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\0026\016\004X(\223\018=\000@|\002\128\003\028\000d \b\024\000\152$\218\000 \026\000\000\004P\000\200@\016 \0010I\180\000@4\000\000\b\160\001\144\128 @\002`\145h\000\128h\000\000\017@D\148\187\131\232>\022\028\015\249p;\193o\206\030F\194\000\139\005\027\226G\160\b\015\128P\000c\128\012\132\001\003\000\019\004\155@\004\003@\000\000\138\000\025\b\002\004\000&\t6\128\b\006\128\000\001\020\0002\016\004\b\000L\018-\000\016\r\000\000\002(\b\146\151p}\007\194\195\129\255.\007x-\249\195\192\200@\016 \0010H\180\000@4\000\000\b \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006B\000\129\128\t\130M\160\002\001\160\000\000A\000\012\132\001\002\000\019\004\155@\004\003@\000\000\130\000\025\b\002\004\000&\t\022\128\b\006\128\000\001\004\000\000\000\000\000\000\000\000@\000\000\000\128\000\144\"\004l \b\176Q\190$z\000\128\248\005\000\0068\000\200@\017\000\1600H\228\000\0000\n\000\012`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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=\237\222\191\213\246\185\253\255\219\135\223\219\127\253\240\016\000\000\000\000\012\0028\000\000\000\000\000\000\000\004l1\b\252U\190\164z|\194\249\007\000f\186\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\176\132\"\193F\248\145\232\002\003\224\020\000\024\224#a\bE\130\141\241#\208\004\007\192(\0001\192\006\004\000\128\128\001\002\b\000\000\016\000\000\000\000\000\012\b\001\000\000\002\004\016\000\000 \000\000\000\000\000\024\016\002\000\000\004\b\000\000\000@\000\000\000\000\000\000\000\000\000\000\b\000@\000\000\000\000\000\b\000\000 \b\b\000\004\024 \000\000\001\000\000\000\000\000\016\000\002\000\000\004\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#a\bE\130\141\241#\208\004\007\192(\0001\192F\194\016\139\005\027\226G\160\b\015\128P\000c\128\012\132!\002\000\019\004\139@\004\003\000\000\000\130\000\000\000\000\000\000\000\000 \000\000\000@\000L\017\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\001\000\000\000\000\b\216@\017`\163|H\244\001\001\240\n\000\012p\001\144\128\"!@`\147\200\000\000`\020\000\024\192\003!\000D\002\128\193'\144\000\000\192(\0001\128\006B\000\136\005\001\130G \000\001\128P\000c\001\018R\238\015\160\248Xp?\237\192\239M\1918x\025\b\002 \020\006\t\028\128\000\006\001@\001\140\004{\219\189\127\171\237s\251\255\183\015\191\182\255\251\224\000\000\000\000\000\016\000P\000\000\000\000\000\000\000\b\216@\017`\163|H\244\001\001\240\n\000\012p\001\144\128 `\002`\147h\000\128h\000\000\017@\003!\000@\128\004\193&\208\001\000\208\000\000\"\128\006B\000\129\000\t\130E\160\002\001\160\000\000E\000\000\000l\000\000\000\000\000\000\000\000\000\000 (\001\027\bZ,\020o\137\030\128 >\001@\001\206\0026\016\004X(\223\018=\000@|\002\128\003\028\000d \b\024\000\152$\218\000 \026\000\000\004P\000\200@\016 \0010I\180\000@4\000\000\b\160\001\144\128 @\002`\145h\000\128h\000\000\017@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\143{w\175\245}\174\127\127\246\225\247\246\223\255<\000\000\000\000\000\003\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\000H\000\000`\000\014\002\000\024\184@\000 \000\000\000\000\000\000\000\006@\000\000\000\001\000\000\000\002\000\000\000\000\001\128\0008\b\000b\225\000\000\128\000\000\000\000\000\000\000\025\000\000\000\000\004\000\000\000\b\000\004\000\000\006\000\000\224 \001\139\132\000\002\000\000\000\000\000\000\000\000d\000\000\000\000\016\000\000\000 \000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\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!\000D\002\128\193#\144\000\000\192(\0001\128\143{w\175\245}\174\127\127\246\225\247\246\223\255|\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\016\000\000\000\000\012\000(\000\000\000\000\000\000\000\004l \b\176Q\190$z\000\128\248\005\000\0068\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\000D\148\187\131\232>\022\028\015\249p;\193o\206\030F\194\000\139\005\027\226G\160\b\015\128P\000c\128\012\132\001\003\000\019\004\155@\004\003@\000\000\138\000\025\b\002\004\000&\t6\128\b\006\128\000\001\020\0002\016\004\b\000L\018-\000\016\r\000\000\002(\b\146\151p}\007\194\195\129\255.\007x-\249\195\209\239n\245\254\175\181\207\239\254\220>\254\219\255\231\162J]\193\244\031\011\014\007\253\184\029\233\183\231\015\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\132l \b\176Q\190$z\000\128\248\005\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000D\148\187\131\232>\022\028\015\249p;\193o\206\030F\194\000\139\005\027\226G\160\b\015\128P\000c\128\012\132\001\003\000\019\004\155@\004\003@\000\000\138\000\025\b\002\004\000&\t6\128\b\006\128\000\001\020\0002\016\004\b\000L\018-\000\016\r\000\000\002(\b\146\151p}\007\194\195\129\255.\007x-\249\195\209%.\224\250\015\133\135\003\254\\\014\240[\243\135\145\176\128\"\193F\248\145\232\002\003\224\020\000\024\224\003!\000@\192\004\193&\208\001\000\208\000\000\"\128\006B\000\129\000\t\130M\160\002\001\160\000\000E\000\012\132\001\002\000\019\004\139@\004\003@\000\000\138\002$\165\220\031A\240\176\224\127\203\129\222\011~p\244IK\184>\131\225a\192\255\151\003\188\022\252\225\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\239n\245\254\175\181\207\239\254\220>\254\219\255\231\162J]\193\244\031\011\014\007\253\184\029\233\183\231\015#a\000E\130\141\241#\208\004\007\192(\0001\192\006B\000\129\128\t\130M\160\002\001\160\000\000E\000\012\132\001\002\000\019\004\155@\004\003@\000\000\138\000\025\b\002\004\000&\t\022\128\b\006\128\000\001\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\025\253n\241\250\175\253\207\247\255]\254\250[\255\247\190\251\"\004\023\241\168\000&\014\007\184\224\176(4#a\000E\130\141\241#\208\004\007\192(\0001\192\000\000\000\000\000\000\000\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\027\b\002,\020o\137\030\128 >\001@\001\142\0002\016\004\012\000L\018m\000\016\r\000\000\002(\000d \b\016\000\152$\218\000 \026\000\000\004P\000\200@\016 \0010H\180\000@4\000\000\b\160\"J]\193\244\031\011\014\007\252\184\029\224\183\231\015D\148\187\131\232>\022\028\015\249p;\193o\206\030F\194\000\139\005\027\226G\160\b\015\128P\000c\128\012\132\001\003\000\019\004\155@\004\003@\000\000\138\000\025\b\002\004\000&\t6\128\b\006\128\000\001\020\0002\016\004\b\000L\018-\000\016\r\000\000\002(\b\146\151p}\007\194\195\129\255.\007x-\249\195\209%.\224\250\015\133\135\003\254\\\014\240[\243\135\145\176\128\"\193F\248\145\232\002\003\224\020\000\024\224\003!\000@\192\004\193&\208\001\000\208\000\000\"\128\006B\000\129\000\t\130M\160\002\001\160\000\000E\000\012\132\001\002\000\019\004\139@\004\003@\000\000\138\002$\165\220\031A\240\176\224\127\203\129\222\011~p\244IK\184>\131\225a\192\255\151\003\188\022\252\225\228l \b\176Q\190$z\000\128\248\005\000\0068\000\200@\0160\0010I\180\000@4\000\000\b\160\001\144\128 @\002`\147h\000\128h\000\000\017@\003!\000@\128\004\193\"\208\001\000\208\000\000\"\128\137)w\007\208|,8\031\242\224w\130\223\156=\018R\238\015\160\248Xp?\229\192\239\005\1918y\027\b\002,\020o\137\030\128 >\001@\001\142\0002\016\004\012\000L\018m\000\016\r\000\000\002(\000d \b\016\000\152$\218\000 \026\000\000\004P\000\200@\016 \0010H\180\000@4\000\000\b\160\"J]\193\244\031\011\014\007\252\184\029\224\183\231\015D\148\187\131\232>\022\028\015\249p;\193o\206\030F\194\000\139\005\027\226G\160\b\015\128P\000c\128\012\132\001\003\000\019\004\155@\004\003@\000\000\138\000\025\b\002\004\000&\t6\128\b\006\128\000\001\020\0002\016\004\b\000L\018-\000\016\r\000\000\002(\b\146\151p}\007\194\195\129\255.\007x-\249\195\209%.\224\250\015\133\135\003\254\\\014\240[\243\135\145\176\128\"\193F\248\145\232\002\003\224\020\000\024\224\003!\000@\192\004\193&\208\001\000\208\000\000\"\128\006B\000\129\000\t\130M\160\002\001\160\000\000E\000\012\132\001\002\000\019\004\139@\004\003@\000\000\138\002$\165\220\031A\240\176\224\127\203\129\222\011~p\244IK\184>\131\225a\192\255\151\003\188\022\252\225\228l \b\176Q\190$z\000\128\248\005\000\0068\000\200@\0160\0010I\180\000@4\000\000\b\160\001\144\128 @\002`\147h\000\128h\000\000\017@\003!\000@\128\004\193\"\208\001\000\208\000\000\"\128\137)w\007\208|,8\031\242\224w\130\223\156=\018R\238\015\160\248Xp?\229\192\239\005\1918y\027\b\002,\020o\137\030\128 >\001@\001\142\0002\016\004\012\000L\018m\000\016\r\000\000\002(\000d \b\016\000\152$\218\000 \026\000\000\004P\000\200@\016 \0010H\180\000@4\000\000\b\160\"J]\193\244\031\011\014\007\252\184\029\224\183\231\015D\148\187\131\232>\022\028\015\249p;\193o\206\030F\194\000\139\005\027\226G\160\b\015\128P\000c\128\012\132\001\003\000\019\004\155@\004\003@\000\000\138\000\025\b\002\004\000&\t6\128\b\006\128\000\001\020\0002\016\004\b\000L\018-\000\016\r\000\000\002(\b\146\151p}\007\194\195\129\255.\007x-\249\195\209%.\224\250\015\133\135\003\254\\\014\240[\243\135\145\176\128\"\193F\248\145\232\002\003\224\020\000\024\224\003!\000@\192\004\193&\208\001\000\208\000\000\"\128\006B\000\129\000\t\130M\160\002\001\160\000\000E\000\012\132\001\002\000\019\004\139@\004\003@\000\000\138\002$\165\220\031A\240\176\224\127\203\129\222\011~p\244IK\184>\131\225a\192\255\151\003\188\022\252\225\228l \b\176Q\190$z\000\128\248\005\000\0068\000\200@\0160\0010I\180\000@4\000\000\b\160\001\144\128 @\002`\147h\000\128h\000\000\017@\003!\000@\128\004\193\"\208\001\000\208\000\000\"\128\137)w\007\208|,8\031\242\224w\130\223\156=\018R\238\015\160\248Xp?\229\192\239\005\1918y\027\b\002,\020o\137\030\128 >\001@\001\142\0002\016\004\012\000L\018m\000\016\r\000\000\002(\000d \b\016\000\152$\218\000 \026\000\000\004P\000\200@\016 \0010H\180\000@4\000\000\b\160\"J]\193\244\031\011\014\007\252\184\029\224\183\231\015D\148\187\131\232>\022\028\015\249p;\193o\206\030F\194\000\139\005\027\226G\160\b\015\128P\000c\128\012\132\001\003\000\019\004\155@\004\003@\000\000\138\000\025\b\002\004\000&\t6\128\b\006\128\000\001\020\0002\016\004\b\000L\018-\000\016\r\000\000\002(\b\146\151p}\007\194\195\129\255.\007x-\249\195\209%.\224\250\015\133\135\003\254\\\014\240[\243\135\145\176\128\"\193F\248\145\232\002\003\224\020\000\024\224\003!\000@\192\004\193&\208\001\000\208\000\000\"\128\006B\000\129\000\t\130M\160\002\001\160\000\000E\000\012\132\001\002\000\019\004\139@\004\003@\000\000\138\002$\165\220\031A\240\176\224\127\203\129\222\011~p\244IK\184>\131\225a\192\255\151\003\188\022\252\225\228l \b\176Q\190$z\000\128\248\005\000\0068\000\200@\0160\0010I\180\000@4\000\000\b\160\001\144\128 @\002`\147h\000\128h\000\000\017@\003!\000@\128\004\193\"\208\001\000\208\000\000\"\128\137)w\007\208|,8\031\242\224w\130\223\156=\018R\238\015\160\248Xp?\229\192\239\005\1918y\027\b\002,\020o\137\030\128 >\001@\001\142\0002\016\004\012\000L\018m\000\016\r\000\000\002(\000d \b\016\000\152$\218\000 \026\000\000\004P\000\200@\016 \0010H\180\000@4\000\000\b\160\"J]\193\244\031\011\014\007\252\184\029\224\183\231\015D\148\187\131\232>\022\028\015\249p;\193o\206\030F\194\000\139\005\027\226G\160\b\015\128P\000c\128\012\132\001\003\000\019\004\155@\004\003@\000\000\138\000\025\b\002\004\000&\t6\128\b\006\128\000\001\020\0002\016\004\b\000L\018-\000\016\r\000\000\002(\b\146\151p}\007\194\195\129\255.\007x-\249\195\209%.\224\250\015\133\135\003\254\\\014\240[\243\135\145\176\128\"\193F\248\145\232\002\003\224\020\000\024\224\003!\000@\192\004\193&\208\001\000\208\000\000\"\128\006B\000\129\000\t\130M\160\002\001\160\000\000E\000\012\132\001\002\000\019\004\139@\004\003@\000\000\138\002$\165\220\031A\240\176\224\127\203\129\222\011~p\244IK\184>\131\225a\192\255\151\003\188\022\252\225\228l \b\176Q\190$z\000\128\248\005\000\0068\000\200@\0160\0010I\180\000@4\000\000\b\160\001\144\128 @\002`\147h\000\128h\000\000\017@\003!\000@\128\004\193\"\208\001\000\208\000\000\"\128\137)w\007\208|,8\031\242\224w\130\223\156=\018R\238\015\160\248Xp?\229\192\239\005\1918x\025\b\002\004\000&\t6\128\b\006\000\000\001\004\0002\016\004\b\000L\018-\000\016\012\000\000\002\b\000\245$Z\019\004\154g\214\003 \031`\001\188U\b\216@\017`\163|H\244\001\001\240\n\000\012p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\128\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\024\000\003\128\128\006.\016\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\128\000\000\000\004l \b\176Q\190$z\000\128\248\005\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\001\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\012\000\001\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000@\000\000\000\0026\016\004X(\223\018=\000@|\002\128\003\028\000\000\000\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\017\176\128\"\193F\248\145\232\002\003\224\020\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\018\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\004l \b\176Q\190$z\000\128\248\005\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\016\000\019\004@\012\000\001\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000@\000\000\000\0026\016\004X(\223\018=\000@|\002\128\003\028\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\002\000\002@\136\017\176\128\"\193F\248\145\232\002\003\224\020\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006B\000\129\000\t\130E\160\002\001\160\000\000A\000\000\000\000\000\000\000\000\016\000\000\000 \000$\b\128\025\b\002\004\000&\t\022\128\b\006\128\000\001\004\000\000\000\000\000\000\000\000@\000\000\000\128\000\144\"\000d \b\016\000\152$Z\000 \026\000\000\004\016\000\000\000\000\000\000\000\001\000\000\000\002\000\002@\136\000\000\000\000\000\000`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000@\000H\017\0002\016\004\b\000L\018-\000\016\r\000\000\002\b\000\000\000\000\000\000\000\000\128\000\000\001\000\001 D\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002@\017@\004\016\t\012\000\012\128\025\128\000 \004\004\128\"\128\b\"\018\024\012\025\0003\000 @\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004IK\184>\131\225a\192\255\151\003\188\022\252\225\228l \b\176Q\190$z\000\128\248\005\000\0068\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000#a\000E\130\141\241#\208\004\007\192(\0001\192\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\144\000\000\000\000\000\000\000\000\b\000(\000\000\000\000\000\000\000\004l \b\176Q\190$z\000\128\248\005\000\0068\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\155\003\224\012\004\004\003\224\016\b\000\011\012\006F\194\022\139\005\027\226G\160\b\015\128P\000s\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\027\b\002,\020o\137\030\128 >\001@\001\142\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\216@\017`\163|H\244\001\001\240\n\000\012p\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\132\001\016\n\003\004\142@\000\003\000\160\000\198\002=\237\222\191\213\246\185\253\255\219\135\223\219\127\253\240\000\000\000\000\000\b\000(\000\000\000\000\000\000\000\004l \b\176Q\190$z\000\128\248\005\000\0068\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000#\222\221\235\253_o\159\223\253\184}\253\183\255\207#a\000E\130\141\241#\208\004\007\192(\0001\192\006B\000\129\128\t\130M\160\002\001\160\000\000E\000\012\132\001\002\000\019\004\155@\004\003@\000\000\138\000\025\b\002\004\000&\t\022\128\b\006\128\000\001\020\004IK\184>\131\225a\192\255\151\003\188\022\252\225\232\146\151p}\007\194\195\129\255.\007x-\249\195\200\216@\017`\163|H\244\001\001\240\n\000\012p\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000G\189\187\215\250\190\223?\191\251p\251\251o\255\158F\194\000\139\005\027\226G\160\b\015\128P\000c\128\012\132\001\003\000\019\004\155@\004\003@\000\000\138\000\025\b\002\004\000&\t6\128\b\006\128\000\001\020\0002\016\004\b\000L\018-\000\016\r\000\000\002(\b\146\151p}\007\194\195\129\255.\007x-\249\195\209%.\224\250\015\133\135\003\254\\\014\240[\243\135\145\176\128\"\193F\248\145\232\002\003\224\020\000\024\224\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\143{w\175\245}\190\127\127\246\225\247\246\223\255<\141\132\001\022\n7\196\143@\016\031\000\160\000\199\000\025\b\002\006\000&\t6\128\b\006\128\000\001\020\0002\016\004\b\000L\018m\000\016\r\000\000\002(\000d \b\016\000\152$Z\000 \026\000\000\004P\017%.\224\250\015\133\135\003\254\\\014\240[\243\135\162J]\193\244\031\011\014\007\252\184\029\224\183\231\015\001\000\000\000\000\000\192\002\128\000\000\000\000\000\000\000F\194\000\139\005\027\226G\160\b\015\128P\000c\128\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\002=\237\222\191\213\246\249\253\255\219\135\223\219\127\252\2426\016\004X(\223\018=\000@|\002\128\003\028\000d \b\024\000\152$\218\000 \026\000\000\004P\000\200@\016 \0010I\180\000@4\000\000\b\160\001\144\128 @\002`\145h\000\128h\000\000\017@D\148\187\131\232>\022\028\015\249p;\193o\206\030\137)w\007\208|,8\031\242\224w\130\223\156<\141\132\001\022\n7\196\143@\016\031\000\160\000\199\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\004{\219\189\127\171\237\243\251\255\183\015\191\182\255\249\228l \b\176Q\190$z\000\128\248\005\000\0068\000\200@\0160\0010I\180\000@4\000\000\b\160\001\144\128 @\002`\147h\000\128h\000\000\017@\003!\000@\128\004\193\"\208\001\000\208\000\000\"\128\137)w\007\208|,8\031\242\224w\130\223\156=\018R\238\015\160\248Xp?\229\192\239\005\1918y\027\b\002,\020o\137\030\128 >\001@\001\142\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\b\247\183z\255W\219\231\247\255n\031\127m\255\243\200\216@\017`\163|H\244\001\001\240\n\000\012p\001\144\128 `\002`\147h\000\128h\000\000\017@\003!\000@\128\004\193&\208\001\000\208\000\000\"\128\006B\000\129\000\t\130E\160\002\001\160\000\000E\001\018R\238\015\160\248Xp?\229\192\239\005\1918z$\165\220\031A\240\176\224\127\203\129\222\011~p\240\000\000\000\000\000\000\000\000\000\000\000\001 \000\000\000\000\000\000\000\000\016\000P\000\000\000\000\000\000\000\b\216@\017`\163|H\244\001\001\240\n\000\012p\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000G\189\187\215\250\190\223?\191\251p\251\251o\255\158F\194\000\139\005\027\226G\160\b\015\128P\000c\128\012\132\001\003\000\019\004\155@\004\003@\000\000\138\000\025\b\002\004\000&\t6\128\b\006\128\000\001\020\0002\016\004\b\000L\018-\000\016\r\000\000\002(\b\146\151p}\007\194\195\129\255.\007x-\249\195\209%.\224\250\015\133\135\003\254\\\014\240[\243\135\145\176\128\"\193F\248\145\232\002\003\224\020\000\024\224\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\143{w\175\245}\190\127\127\246\225\247\246\223\255<\141\132\001\022\n7\196\143@\016\031\000\160\000\199\000\025\b\002\006\000&\t6\128\b\006\128\000\001\020\0002\016\004\b\000L\018m\000\016\r\000\000\002(\000d \b\016\000\152$Z\000 \026\000\000\004P\017%.\224\250\015\133\135\003\254\\\014\240[\243\135\162J]\193\244\031\011\014\007\252\184\029\224\183\231\015#a\000E\130\141\241#\208\004\007\192(\0001\192\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\001\030\246\239_\234\251|\254\255\237\195\239\237\191\254y\027\b\002,\020o\137\030\128 >\001@\001\142\0002\016\004\012\000L\018m\000\016\r\000\000\002(\000d \b\016\000\152$\218\000 \026\000\000\004P\000\200@\016 \0010H\180\000@4\000\000\b\160\"J]\193\244\031\011\014\007\252\184\029\224\183\231\015D\148\187\131\232>\022\028\015\249p;\193o\206\030\143{w\175\245}\190\127\127\246\225\247\246\223\255<\141\132\001\022\n7\196\143@\016\031\000\160\000\199\000\025\b\002\006\000&\t6\128\b\006\128\000\001\020\0002\016\004\b\000L\018m\000\016\r\000\000\002(\000d \b\016\000\152$Z\000 \026\000\000\004P\017%.\224\250\015\133\135\003\254\\\014\240[\243\135\162J]\193\244\031\011\014\007\252\184\029\224\183\231\015G\189\187\215\250\190\215?\191\251p\251\251o\255\190\143{w\175\245}\174\127\127\242\225\247\210\223\255<\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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#a\000E\130\141\241#\208\004\007\192(\0001\192\000\000\004\000\000\000\000\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\027\b\002,\020o\137\030\128 >\001@\001\142\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\004\000\004\129\016#a\000E\130\141\241#\208\004\007\192(\0001\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000A\027\b\002,\020o\137\030\128 >\001@\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000d \b\016\000\152$Z\000 \024\000\000\004\016\000\000\000\000\000\000\000\000\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!\bD\002\128\193#\144\000\000\192(\0001\128\000\000\016\000\000\000\000\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\027\b\002,\020o\137\030\128 >\001@\001\206\000\000\000\000\000\000\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\017\176\129\"\193F\248\145\232\002\003\224\020\000\024\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\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\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200@\017\000\1600H\228\000\0000\n\000\012` \000\000\000\000\000\000\000\000\001\128\000\t\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\000D\000\000\000\000\000\000\000\000 \000\018\000\000\000\000\136\000\000\000\000\000\000\000\000@\000\000\000\000\000\001\016\000\000\000\000\000\000\000\000\000\000\000\000\000 \000 \000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\000\000\000\000\000\000\000\000\000\012\000\000H\000\000\000\b\000\000\000\000\006\001\028\000\000\000\000\000\000\000\004\000\001\016\000\000\000\000\000\0000\000\129 H\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000F\194\000\139\005\027\226G\160\b\015\128P\000c\128\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\001\027\b\002,\020o\137\030\128 >\001@\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017%.\224\250\015\133\135\003\254\\\014\240[\243\135\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000F\194\000\139\005\027\226G\160\b\015\128P\000c\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\027\b\002,\020o\137\030\128 >\001P\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\"J]\193\244\031\011\014\007\252\184\029\224\183\231\015\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000F\194\000\139\005\027\226G\160\b\015\128P\000c\128\012\132\001\003\000\019\004\155@\004\003@\000\000\138\000\025\b\002\004\000&\t6\128\b\006\128\000\001\020\0002\016\004\b\000L\018-\000\016\r\000\000\002(\b\146\151p}\007\194\195\129\255.\007x-\249\195\200\216@\017`\163|H\244\001\001\240\n\000\012p\001\144\128 `\002`\147h\000\128h\000\000\017@\003!\000@\128\004\193&\208\001\000\208\000\000\"\128\006B\000\129\000\t\130E\160\002\001\160\000\000E\001\018R\238\015\160\248Xp?\229\192\239\005\1918z$\165\220\031A\240\176\224\127\203\129\222\011~p\244IK\184>\131\225a\192\255\151\003\188\022\252\225\228l \b\176Q\190$z\000\128\248\005\000\0068\000\200@\0160\0010I\180\000@4\000\000\b\160\001\144\128 @\002`\147h\000\128h\000\000\017@\003!\000@\128\004\193\"\208\001\000\208\000\000\"\128\137)w\007\208|,8\031\242\224w\130\223\156=\018R\238\015\160\248Xp?\229\192\239\005\1918x\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017%.\224\250\015\133\135\003\254\220\014\244\219\243\135\129\144\128 `\002`\147h\000\128h\000\000\017@\003!\000@\128\004\193&\208\001\000\208\000\000\"\128\006B\000\129\000\t\130E\160\002\001\160\000\000E\000\000\000\000\000\000\000\000\000\000\000\128\000\000 \b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000>\000\192@@>\003\000\128\000\176@`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\239n\245\254\175\181\207\239\254\220>\254\219\255\239\128\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006B\000\129\128\t\130M\160\002\001\160\000\000E\000\012\132\001\002\000\019\004\155@\004\003@\000\000\138\000\025\b\002\004\000&\t\022\128\b\006\128\000\001\020\000\000\001\016\000\000\000\000\000\000\004\000\000\000\128 \000\000\018 |\001\128\128\128|\n\001\000\001`\128\192\000\004\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000 \000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\129\000 \000\000@\130\000\000\004\000\000\000\000\000\003\002\000@\000\000\129\000\000\000\b\000\000\000\000\000\000\000\000\000\000\001\000\b\000\016\000\000\000\000\000\000\141\132\001\022\n7\196\143@\016\031\000\160\000\199\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\000\004\000\000\000@\000\000\000\000\000\000\000\000`\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\004\000\000@\000\003\002\000@\000\000\129\000\000\000\b\000\000\000\000\000\t\000E\000\016A$8\0002\000f\000\000\128\016\004\001\001\000\000\131\004\000\000\000 \000\000\000\000\002\000\000\000\000\000\128\000 \000\000\000@\000\000\000\0000 \004\000\000\b\016\000\000\000\128\000\000\000\000\000\144\004P\001\004\018C\128\003 \006`\000\b\001\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\017\176\128\"\193F\248\145\232\002\003\224\020\000\024\224\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\016\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\000\002\000\004\0000\000\000\002\000\000\000\000\000\018\000\000\000\000\b\000`\000\000\004\000\000\000\000\000$\000\000\000\000\016\000@\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000 \000@\000\000\000\004\000\0000\000\006\000\000\012\\(\000\016\000\000\000\000\000\000\000\000\000\000\b\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\006\000\000\224 \001\139\132\000\002\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\b\000\000\000\024\000\003\128\128\006.\016\000\b\000\000\000\000\000\000\000\001\016\000\000\000\000@\000\001\000\000\000\000\002\000\000\002 \000\000\000\000\128\000\000\000\000\000\000\000\000\000\004@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\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\b\000\000 \000\000\000\000@\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\004\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000`\000\000\197\194\000\001\000\000\000\000\000\000\011\001E\000\016`\1648\0002\000f\000@\132\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000,\005\020\000A\002\144\224\000\200\001\152\001\002\016@0\000\006\000\000\012\\(\000\016\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000@\000\000\000\192\000\024\000\0001p\160\000@\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\003\000\000`\000\000\197\194\000\001\000\000\000\000\000\000\011\000E\000\016@\1648\0002\000f\000@\132\016\022\002\138\000 \193Hp\000d\000\204\000\129\b \000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\0000\000\006\000\000\012\\ \000\016\000\000\000\000\000\000\176\004P\001\004\nC\128\003 \006`\004\bA\001`(\160\002\012\020\135\000\006@\012\192\b\016\130\000\000\000\000\000\000\000\002\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000F\194\000\139\005\027\226G\160\b\015\128P\000c\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0002\016D\b\000L\018m\000\016\012\000\000\002\b\000d \136\016\000\152$Z\000 \024\000\000\004\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\144\128 @\002`\145h\000\128`\000\000\016@\004\128\"\128\b \018\024\000\025\0003\000\000@\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\144\128 `\002`\147h\000\128h\000\000\017@\003!\000@\128\004\193&\208\001\000\208\000\000\"\128\006B\000\129\000\t\130E\160\002\001\160\000\000E\001\018R\238\015\160\248Xp?\229\192\239\005\1918z$\165\220\031A\240\176\224\127\203\129\222\011~p\240\000\000\000\000\000\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\003\002\000@@\000\129\004\000\000\b\000\000\000\000\000\006\004\000\128\000\001\002\b\000\000\016\000\000\000\000\000\012\b\001\000\000\002\004\000\000\000 \000\000\000\000\000\000\000@\000\000\004\000 \000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \b\b\000\004\024 \000\000\001\000\000\000\000\000\016\000\002\000\000\004\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\b\000\000\000\000\000\000\000\000\000\000\004\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000d \b\016\000\152$Z\000 \026\000\000\004P\017%.\224\250\015\133\135\003\254\\\014\240[\243\135\129\144\128 `\002`\147h\000\128h\000\000\017@\003!\000@\128\004\193&\208\001\000\208\000\000\"\128\006B\000\129\000\t\130E\160\002\001\160\000\000E\000\000\000 \000\000\000\000\000\000\000\000\000\0002\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\004\004\000\002\012\016\000\000\000\128\000\000\000\000\b\000\001\000\000\002\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128 \000\016`\128\000\000\004\000\000\000\000\000@\000\b\000\000\016\000\004\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\001\001\000\000\131\004\000\000\000 \000\000\000\000\002\000\000@\000\000\128\000 \000\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|\001\128\128\128|\002\001\000\001\240\128\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128 \000\016`\128\000\000\004\000\000\000\000\000@\000\b\000\000\016\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\001\001\000\000\131\004\000\000\000 \000\000\000\000\002\000\000@\000\000\128\000 \000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \b\b\000\004\024 \000\000\001\000\000\000\000\000\016\000\002\000\000\004\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\004\128\"\128\b \146\028\000\017\0003\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\b\001\000\000\002\004\016\000\000 \000\000\000\000\000\024\016\002\000\000\004\b\000\000\000@\000\000\000\000\000H\002(\000\130\t!\192\001\016\0030\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\224\001\000\016\000\000\001\000\000\000\000\000\000\000\000\000\128\000\000 \000 \002\000\000\000\000\000\000\000\000\001\000\000\000\000\000@\004\000\000\000\000\000\000\000\000\002\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\018\000\138\000 \128H`\000D\000\236\000\001\000\000\b\002\002\000\001\006\b\000\000\000@\000\000\000\000\004H\002(\000\131\001!\192\001\016\0030\000\004\000\000\144\004P\001\004\002C\000\002 \006`\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\128\002\000\000\000\000\002\000\000\000\000\000\000\000\000\003\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\006\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\002\000\000$\001\020\000A\000\144\192\000\136\001\152\000\002\000@H\002(\000\130\001!\000\001\016\0030\000\004\000\128`\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\004\000\000@\000\004\128\"\128\b \018\024\000\017\0003\000\000@\b\t\000E\000\016@$ \000\"\000f\000\000\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\128\000\b\000\000\144\004P\001\004\002C\000\002 \006`\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000>\251\"\004\023\241\168\000&\014\007\184\224\176(4'\225\"\213\138\173\2433\208\020\007\240(\000\241\192\006B\000\129\000\t\130E\160\002\001\160\000\000A\000@\000\b\000\000\000\000\016\000\000\000\000\000$\b\129\027\b\002,\020o\137\030\128 >\001@\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\190\200\129\005\252j\000\t\131\129\2388,\n\r\t\248H\181b\171|\204\244\005\001\252\n\000\001@\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\001\000\000\b\000\128\000\000\000\000\000\000 \000\000\000\002\000\000\016\001\000\000\000\000\000\000\000\000\000\000\000\004\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\012\164\001B@\019\004\138\192\004\003 \000\002\130\000\028\000\003\128\128\006.\016\000\b\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\192\000\028\004\0001p\128\000@\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\004\000\000\000\000#a\000E\130\141\241#\208\004\007\192(\0001\192\000\000\000\000\000\000\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\027\b\002,\020o\137\030\128 >\001@\001\142\000\000\000\000\000\000\000\000\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\128\134\003\000\000\000@\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\b\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\128\000\000\000\000\000\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\b\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\128\0008\b\000b\225\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\012\164\001B@\019\004\138\192\004\003 \000\002\130\000\028\000\003\128\128\006.\016\000\b\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\192\000\028\004\0001p\128\000@\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\004\000\000\000\000#a\000E\130\141\241#\208\004\007\192(\0001\192\000\000\000\000\000\000\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\027\b\002,\020o\137\030\128 >\001@\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\216@\017`\163|I\244\001\001\240\n\000\012p\017\176\128\"\193F\248\145\232\002\003\224\020\000\024\224\004\000\000\128\000\002\002\024\012\000\000\001\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\001\000\b\003D\024\000\000\b\000\000\000\004\000\b\000\002\000\016\006\1360\000\000\016\000\000\000\000\000\016\000\004\000 \r\016 \000\000 \000\000\000\000\000 \000\b\000@\026 @\000\000@\000\000\000\000\000\200A\0162\0010I\180\000@0\000\000\b >\251\"\004\023\241\168\000&\014\007\184\224\176(4\003!\004@\128\004\193&\208\001\000\192\000\000 \128\006B\b\129\000\t\130E\160\002\001\128\000\000A\000\012\132\001\002\000\019\004\139@\004\003\000\000\000\130\000\000\000\000\000\000\000\000@\000@\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\128\000\000\000\000\000\000 \000@\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\002\000\000\000\002\000\000\128\004\001\162\004\000\000\004\000\000\000\000\000\012\000\001\192@\003\023\b\000\004\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000@\000\000\016\000\000\000\000\004\000\000\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@\020$\0010I\172\000@0\000\000\b \001\148\128(H\002`\145X\000\128`\000\000\016@\003)\000P\144\020\193\"\176\001\000\192\000\000 \128\002\000\000\128\004\001\162\004\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000 \b\000\002\000\016\006\136\016\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\245%Z\131TZg\247\130 \030e\004\0305\001\234J\181\006\168\180\207\239\004@<\202\b\022\028\015\249p;\193o\206\030\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\016\000@\000\000\b\000\000\000@\000H\000\000\000\000 \000\128\000\000\016\000\000\000\128\000\144\000\000\000\000@\001\000\000\000 \000\000\000\000\004\128\"\128\012 \018\028\000\017\000;\000\000\194\000\002@\000\000\000\001\000\004\000\000\000\128\000\000\000\000\018\000\138\000 \128Hp\000D\000\204\000\001\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000H\002(\000\130\001!\128\001\016\0030\000\004 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000H\002(\000\194\001!\192\001\016\003\176\000\012 \000$\000\000\000\000\016\000@\000\000\b\000\000\000\000\001 \b\160\002\b\004\135\000\004@\012\192\000\016\128\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\t\000E\004\016@$0\000\"\000v\000@\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\001\020\000A\000\144\192\000\136\001\152\001\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\000H\000\002\000\000 \000\128\000\000\016\000\000\000\128\000\144\000\000\000\000@\001\000\000\000 \000\000\001\000\004\128\"\128\b \018\024\000\017\0003\000\000B\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\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\001\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\002\000\000\000\000\000\000\192\000\024\000\0001q\128\000D\000\001\000\000\000\001\128\0000\000\000b\225\000\000\136\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\004\000@\000\000\001\000\000\000\004@\000\000\000\000\000\024\000\003\000\000\006.\016\000\b\128\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\006\000\000\224 \001\139\132\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\016\000\000\000\000\004\000\000\000\016\000\000\000\000\000\000 \000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000p\016\000\197\194\000\001\000\000\000\000\000\000\000\000\016\000\000\000\000\b\000\000\000\000\000\016\000\000\000\000 \000\000\000\000\016\000\000\000\000\000 \000\000\024\000\003\128\128\006.\016\000\b\000\000\000\000\000\000\000\000\128\000\000\000\000@\000\000\000\000\000\128\000\000\000\000\000\000\b\b\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000E\000\016@$8\000\"\000f\000@\128\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0002\000\007\129\000\012\\(\000\016\004\000@\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \b\160\002\b\000\134\000\004\000\012\192\b\016\002\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\002@\000\016\000\001\000\004\000\000\000\128\000\000\004\000\004\128\000\000\000\002\000\b\000\000\001\000\000\000\b\000$\001\020\000A\000\016\192\000\128\001\152\000\002\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\t\000E\004\016@\0040\000 \000v\000D\128\016\012\128\001\224@\003\023\n\000\004\001\000\016\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000H\002(\000\130\000!\128\001\000\0030\002\004\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\144\000\004\000\000@\001\000\000\000 \000\000\001\000\001 \000\000\000\000\128\002\000\000\000@\000\000\002\000\t\000E\000\016@\0040\000 \000f\000\000\132\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\001\000\000\002\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002@\017@\004\016\t\012\000\b\128\025\128\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\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\027\b\002,\020o\137\030\128 >\001@\001\142\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\004l \b\176Q\190$z\000\128\248\005\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\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\000\000$\001\004\000A\000\016\128\000\128\001\144\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\144\000\000\000\000`\001\000\000\000 \000\000\000\000\000\000\136\007\224\012$\000\003\226\016\b\016\003\005\022\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000@\000\000\000@\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000@\003\240\006\018\000\001\241\b\004\b\001\130\139\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\002@\000\000\000\001\000\004\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000`\000\014\002\000\024\184@\000 \000\000\000\000\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\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000F\194\000\139\005\027\226G\160\b\015\128P\000c\128\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\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\000\000\000\000\000\000\000\000\016\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000`@\b\000\000\016 \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@\002\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\128\128\000A\130\000\000\000\016\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\128\000 \000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\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\006B\000\129\000\t\130E\160\002\001\160\000\000A\000\000\000\000\000\000\000\000\016\000\000\000\b\000$\b\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\004\000\000\000\000\003\000\000\000\000\000\000\000\000\000\001?\t\006,Uo\153\158\128\168?\145@\003\142\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\180$\016\001\004\026B\002\002 \014@\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\004\000A\000\144\128\000\136\001\144\016\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\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128 \128\b \018\016\000\016\0000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\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\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\019\240\144b\197V\249\153\232\n\131\249\020\0008\224'\225 \197\138\173\2433\208\021\007\242(\000q\192\t\000A\000\016@$ \000\"\000d\000\000\128\000\018\000\130\000 \128H@\000D\000\200\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\144\004\016\001\004\002C\000\002 \006@\000\b\000\001 \b \002\b\004\132\000\004@\012\128\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\018\000\130\000 \128H`\000D\000\200\000\001\000\000$\001\004\000A\000\144\128\000\136\001\144\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\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000") and start = 15 and action = - ((16, "I\186T|N\160\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\023\018N\160\000\000\000\000\022\022N\160I\186T|\022\022\000\003\000\000\000\000T|\022\022\000\003T|\022\022\000\003\000\000\000\000\000\000\018\022N\006\021\218P\240^0\000\000\000\025\000\000\000\000\001\030\000\000\000\000P\130\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\002\248\002\160\000\t\000\000\000\000\002\236\000\000Q\168c\208\022\022\\\148\022|\003\168\0001k\026\000\000\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\234\001\132\000\157\000\000\000\168\004B\000\000\000\242\000\226\004J\000\000\005L\002\000\n\\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\234\000\000\000\000\002\160]`\000\000\000\000\000h\000\000\000\000^\002\003<\002\200\000\000\000\000L$\000h\000\000P\172\022\022Q\168\004\130\004\242\003\168\004\176\000\000\022\022I\186TB\022\022_\180\000\000\001<\000\000Yj\004\250\000\000\028x\000\000\000\016\000\000\000\000\001\166\000\000\000h\000\000\000\000\000\000\001\206\000\000\028x\000\000\004\004}\210\133\030k\176\135.O\016YX_\198\000\000s\172\026\018]`N\160I\186I\186\000\000\000\000\000\000I\244I\244\003\168\004\176\004\176\022\022\000\003\025\174\000\208\005\182\000\000\004v\005\186\000\000\000\000\000\000\000\000\000\000\022\022\000\000\000\000\000\000T|\022\022\000\003T|\022\022\000\003G\174w\030I\186\000\252\000\003Tr\022\022\131j\000\000^0{\002~F\000\000\005\182\000\000\0056\000\000\023\164K([\140\000\000K([\140\000\000K(\137z\007\028\006\194\004\004\002\164\000\000\005\164\000\000\000\000\b0\000\000\000\000\000\000K(\000h\000\000\000\000_\180K(^\234_\198\000\000\000\000[J\007\028\000\000\000\000_\198\005\252K(\000\000\\4_\198]\030\000\000\000\000\000\000\003(\000\000K(\000\000\021\024\140N\000\000K(\007VK(\000\000\030.\006\148\000h\000\000\000\000\031,\000\000\bT\000\000a\166\0040\000\000\006\204K(\004|\000\000\004\146\000\000\003\138\000\000\000\003\006b\000\000\000\000\000\000$@\tX^0Tr\022\022^0\000\000\007\028\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000ZR\030\140\000\000\000\000\000\000\001\254\026\002~F\000\000Tr\022\022^0\000\000\000\000Z\160^0\138\012^0\138f\000\000`X\000\000\000\000`\252P\130\004\180\004\180\000\000\b,^0\000\000\000\000\000\000\bB\b~\000\000\027\138\000\000^0\138\152K(\003~\000\000^0\138\230\0001\000\000\000\000\000\000\b\186\000\000\022Z\000\000\129\148\000\000\b\198\000\000QF^0\000\000\000\000H\250\tB\005\182\t\156\000\000\000\000\000\000\000\000\b\180\000\000O\138\006\022\th\007\174K(\016\186\t\200\000\000\000\000\007l\th\t\018\000\003^0b\128\002\254\000\000^0\024\144K(\017\138\t\018\n\152\000\000\000\000\000\000Q~\004\180\n\168pb^0\000\000\000\003T|P&I\244\003\168\004\176\003~\002\004\000\t\000\000\n\132Q\168Q\168\003~\002\004\002\004\000\000\011bQ\168\000\000p\230\001LYj\005\182\005\248\140\158\000\000K(lVK(e&l\222K(\005lK(mh\000\000\t\134\n\150\006\140Q\168qn\000\000\006\196\011\148d\020\000\000\000\000\000\000\000\000Q\168q\246Q\168r~\000\218\004\004e\176\005\186\004\004f:\000\000s\006\001L\000\000\000\000\023f\000\000\025\228\000\000\011x\004\176\000\000d\158S\184\000\000\000$\000\000Q\168\026P\000\000\000\000\000\000cF\000\000\000$\000\003K\178\005\234\t\170\000\003\024\006L\184\018\022\000\003T|\022\022\018\022T|\022\022J\182T|\022\022\000\003Tr\022\022^0^0H\250\000\003Tr\022\022~\214Rz\004\180\012(w\172\000\003Tr\022\022^0\028N\000\003Tr\022\022^0\027\138\000\003\018\022\000\000\000\000\000\000\000\000\001\250\023rH\180\000\000UPV$I\244\003\168\004\176\006\192Q\168\026b\000\000V\248W\204{\002\029LK(\t\174\000\003T|\022\022\018\022\024\006\018\022\003\002\017\254\000\003\000\003\018\022\n\200\012\006\007\220K(#|K(\028\nK(#\154\012P\000\000\000\000\012:\000\000\018\022\004\n\012b\000\000$\236\000\003\r\n\000\000\027\254\000\003\019\020\025\004\000\000\000\000\000\000\000\000\b\224\000\003\000\000\000\000\t\202\000\003\000\000\028\252\000\003\029\250\000\003\030\248\000\000\020\018\026\002\000\003\000\000\000\003N\160\000\003\000\000\000\000\000\003\031\246\000\003 \244\000\003!\242\000\003\"\240\000\003#\238\000\003$\236\000\003%\234\000\003&\232\000\003'\230\000\003(\228\000\003)\226\000\003*\224\000\003+\222\000\003,\220\000\003-\218\000\003.\216\000\003/\214\000\0030\212\000\0031\210\000\0032\208\022\022^0\029\134K(\n\208\000\003\000\000\031\130\000\003\000\000^0 F^0 \128^0!D\0001\000\000\000\000\000\000!~^0\"B\000\000x\020N\160I\186^0N,\000\003\000\000I~\025\174\000\208\000h\133jQ\168\130\000x\020x\020\000\000\000\000\004\002\005\n\000\t\006\n\004\176\127>Q\168\005\198\004\176\127\200x\020\135\140\002\160\000\t\006\nx\020\135\140\000\000\006\n\000\000\000\000\006\nx\020\000\000N\160I\186N\160I\186I\244\003\168\004\176x\020\000\000\022|\003\168\0001\012X]`\n\n\000h\000\000K(x\158\012\142\rX\133\206\000\000x\020\000\000y\004K\198\022\022\005\170\000\000\t\148\r\176\000\000\014 \128,_\198\000=\000\000\014\014\r\162]`\011\030K(#\250\022\022\011\152\021\220\000\000$\248\014l\000\000\000\248\000\000\000\000\014\146_\198f\194\000\000m\242\006\178\n\146\002\004\b&\r\218\022\022x\020\000\000\141\160\011\184_\198\014l_\198s\142gj\014p_\198t,h\018\022\022x\020\000\000\000\000n\200TB\022\022k\254Yj\011\208n\006\133\030\137z\000=\014\168\000\000\000\000t\174yh\022\022\000\000\130d\005\170\000\000\000\000\131\174\000\000\000\000\000\000\128\144\025z\026x\000=\014\224\000\000\000\000\000\000yh\022\022\000\000\000=\015\006\000\000\000\000\000\000\000\000\000\000\131\174\000\000\015\000\027\226\000\000\022\232\137\146\000\000\000\000\000\000\000\000\012\028}\210\133\030\000\000\131\174\000\000\000\000\131\174\000\000\015\014\027\226\022\232\137\146\000\000\140\216\023\152\002\248\000\208\004\004\131\174\000\000\000\208\004\004\131\174\000\000JP\025\174\000\208\000h\133jQ\168x\020\000\000\004\002\006\194\bn\004\004\131\174\000\000\000\t\014tQ\168x\020Y\252\002\160\000\t\014xQ\168x\020Y\252\000\000\000\000\007\018\000\003x\020\000\000Q\168\135\192x\020\000\000\007\018\000\000P\172\022\022Q\168x\020\000\000K\198\022\022\005\170yh#\242\029j\021\220\017\184\000\000\012v\028x\011b\000\000\015\014\014\198\0312\021\218[ZK(\012N\000\000Rf\003\218\006\242\011\232\000\000\011\198\000\000\015L\014\206K(UP\000\000\003\168\017\180\012*\000\000\012`\000\000\015Z\014\216]`Q\236\000\000\022\022\0312\015z\004j\000\208\000\003\002X\0312K(\012\158\007\028\000\000K(\b\238\n\234\000\000\000\000uT\000\000\000\003\005\204\0312u\222UP\000\000\022\022K(\012\168K(H\180Q\236\000\000\014\254\000\000Q\236\000\000\000\000Rf\000\000x\020\136^\021\220\017\184\012v\015b\015$\0312x\020\136^\000\000\000\000\021\220\017\184\012v\015\134\015$\139>Y<_\198\015\202\139>\137z\028\202\015\204\139>_\198\015\220\139>y\232zh\000\000b0\000\000\000\000x\020\138\252\021\220\017\184\012v\015\214\015\\\139>x\020\138\252\000\000\000\000\000\000\140\216\000\000\000\000\000\000\000\000\000\000\000\000\000\000x\020\000\000\136l\022\022M\004\015\228}\210\000\000\131\174\136l\000\000\000\000\139\202\022\022M\004\015\246\015z\133\030\000\000\131\174\139\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\026#\242\021\220\017\184\012v\015\254{\002J\224\021\218P\240V\248\022f\002\210\000=\016\n\n\012\000\003\000\000\015\176\000\003\000\000Q\236\000\000\007\222\012\230\000\000\r^\000\000\016\020\015\156K(O\156\016\"\012\b\000\003\000\000\015\214\000\003\000\000\022\138\003\168\r(\016J{\132]`\004\180\015\224K(\rp\000\003\000\000\015\252\000\003\000\000\000\000\000\000pb\015\254\000\003\000\000\000\000\000\000Q\236\000\000\021\182\rd\000\000\r\132\000\000\016\\\015\218]`\000\000\016`|\006_,\004\180\015\254K(\rv\000\003\000\000\016(\000\003\000\000\000\000\022\022\000\003Q\236\000\000\022<\022\022J\224J\224|\250N\160\022\022\131j^0\n\200\000\000\021\178\000\208\000\003\tZJ\224K(\r\228\005\182\000\000\022\022{\002{\002J\224\r\136J\224\000\000L\166\018\022\005\018\006\026M\160\000\000\000\000\000\000hv\000\000\000\000i\000\000\000\000\000i\138\000\003\r\138J\224j\020\131j^0\n\200\000\000\007\012\000\000\139>\016\198\000\000G\174\016\166\000\000Q\236\000\000J\224G\174Q\236\000\000\022\022K(Q\236\000\000\016X\000\000Q\236\000\000\000\000V\248\000\000\1328\139>\016`J\224\132\156{\002\000\000x\020\137\b\021\220\017\184\012v\016\198{\002x\020\137\b\000\000\000\000\000\000\129vTr\022\022\131j^0x\020\000\000\000\000\000\000\000\000\000\000\000\000\1342\000\000\000\000\134\180\000\000x\020\000\000\136l\000\000\000\000\000\000\000\000x\020\129v\000\000\017\004\000\000\1342\000\000\134\180\017\022\000\000\017\026\000\000\000\0003\206\000\003\017,\000\000\000\003\017.\000\000\012\230\018\252\000\003\0178\000\000j\160J\182\000\000\000\003\017@\000\000\000\003\017@\000\000\000\000\019\250\000\003\017N\007\"\000\0034\204\000\003\017V\b \000\0035\202\000\003\017V\t\030\000\0036\200%\234\000\003\017l\n\028\000\0037\198\000\003\017\128\011\026\000\0038\196\000\003\017\142\012\024\000\0039\194\012\246\020\248\000\003\017\152\r\022\000\003:\192\000\003\017\150\014\020\000\003;\190\000\003\017\178\015\018\000\003<\188\016\016\000\003=\186\021\016\000\000\017\190\000\000\000\003\017\234\000\000\000\003\017\236\000\000\000\000\"|\000\003\000\000\007\214\000\003\000\000^0\000\000\000\000|x\018\n\000\000K\178\000\000\017P\000\000X\158\000\000\018\"\000\000\005\234\017\190\000\000\024\006\031r\005\182\000\000\031\192\000\000\011T\014N\023|\000\000\000\000\018:\000\000\001t\027\000R\128\000\000\014(\000\000\000\000\000\003\017\154\000\003\017\160\000\000\017\176\000\003\017\182\000\000\000\003\014(\000\003\017\194\000\003\017\222\000\000\000\000Sv\004\180\018\146w\172_\198\t\240\000\003\000\000w\172\000\000\000\000\000\000w\172\000\000\018l\000\003\000\000\000\003\000\000\000\000\000\000>\184^0\000\000\000\000\018\170\000\003?\182\000\003@\180\000\000\018\000\000\000\027\000j\160\000\000\017\014\018\154\000\000vP\014\"\014\136\000\000\000\000\018$\000\000\018\172\000\000\000\000\003\168\004\176\023\160\000\003\000\000\002\248\002\160\000\t\006\n\018L\000\003\000\000K\198\022\022\005\170\000\230\003~\018R\000\003\000\000\000\000\000\000\000\000\000\000\018\204\000\000\000\000\141\024\004\180\018\006\246\n)\n)\n)\n)\002J\001\154\n)\n)\n)\n)\000\238\n)\n)\004i\n)\n)\n)\b\026\n)\n)\n)\n)\004i\n)\000\n\n)\n)\n)\n)\n)\n)\n)\n)\001\246\n)\000\238\n)\004\202\n)\n)\n)\n)\n)\006\250\007\022\n)\n)\n)\002\014\n)\002\030\n)\n)\n)\002\237\004J\n)\n)\n)\n)\n)\n)\n)\002V\n)\n)\n)\n)\n)\n)\n)\n)\n)\n)\n)\002v\n)\n)\006B\n)\n)\n)\004i\002z\004i\004i\005>\n)\n)\n)\n)\n)\n)\004i\n)\n)\n)\n)\n)\t\174\n)\001\158\n\006\n)\004i\n)\n)\004i\n)\n)\n)\n)\n)\n)\n)\n)\n)\n)\n)\n)\n)\000\238\n)\n)\n)\n)\n)\003\201\004i\004i\004i\002^\003\201\003\201\003\201\003\201\004i\004\206\003\201\003\201\003\201\003\201\000\238\003\201\003\201\004i\003\201\003\201\003\201\005B\003\201\003\201\003\201\003\201\004i\003\201\027\247\003\201\003\201\003\201\003\201\003\201\003\201\003\201\003\201\004i\003\201\000\238\003\201\005\030\003\201\003\201\003\201\003\201\003\201\003\026\006}\003\201\003\201\003\201\006\133\003\201\004i\003\201\003\201\003\201\004\206\000\238\003\201\003\201\003\201\003\201\003\201\003\201\003\201\002\158\003\201\003\201\003\201\003\201\003\201\003\201\003\201\003\201\003\201\003\201\003\201\005.\t\166\t\254\002\n\003\201\003\201\003\201\002\026\003r\002\170\001\006\0056\003\201\003\201\003\201\003\201\003\201\003\201\002\174\003\201\003\201\003\201\003\201\003\201\t\174\003\201\006\025\n\006\003\201\001*\003\201\003\201\000\238\003\201\003\201\003\201\003\201\003\201\003\201\003\201\003\201\003\201\003\201\003\201\003\201\003\201\012Q\003\201\003\201\003\201\003\201\003\201\003\185\003n\001\142\001\146\006\002\003\185\003\185\003\185\003\185\003F\b\237\003\185\003\185\003\185\003\185\012Q\003\185\003\185\011\222\003\185\003\185\003\185\002\162\003\185\003\185\003\185\003\185\007\241\003\185\003\142\003\185\003\185\003\185\003\185\003\185\003\185\003\185\003\185\007N\003\185\016\"\003\185\004\014\003\185\003\185\003\185\003\185\003\185\004\206\001\250\003\185\003\185\003\185\003\129\003\185\b\213\003\185\003\185\003\185\004\206\006\025\003\185\003\185\003\185\003\185\003\185\003\185\003\185\000\238\003\185\003\185\003\185\003\185\003\185\003\185\003\185\003\185\003\185\003\185\003\185\004N\t\166\t\254\012\170\003\185\003\185\003\185\001\"\006\154\001\006\007\138\003\146\003\185\003\185\003\185\003\185\003\185\003\185\000\238\003\185\003\185\003\185\003\185\003\185\t\174\003\185\004\213\n\006\003\185\000\238\003\185\003\185\002\214\003\185\003\185\003\185\003\185\003\185\003\185\003\185\003\185\003\185\003\185\003\185\003\185\003\185\012\174\003\185\003\185\003\185\003\185\003\185\003\181\003\134\b\006\003\150\bZ\003\181\003\181\003\181\003\181\012\186\007\190\003\181\003\181\003\181\003\181\b\213\003\181\003\181\000\238\003\181\003\181\003\181\000\238\003\181\003\181\003\181\003\181\b\150\003\181\004\166\003\181\003\181\003\181\003\181\003\181\003\181\003\181\003\181\005~\003\181\016f\003\181\007V\003\181\003\181\003\181\003\181\003\181\006\190\006\214\003\181\003\181\003\181\0287\003\181\011\246\003\181\003\181\003\181\005J\024b\003\181\003\181\003\181\003\181\003\181\003\181\003\181\b\026\003\181\003\181\003\181\003\181\003\181\003\181\003\181\003\181\003\181\003\181\003\181\007\154\t\166\t\254\001\006\003\181\003\181\003\181\001\"\004\250\011\230\001\142\014\226\003\181\003\181\003\181\003\181\003\181\003\181\007\162\003\181\003\181\003\181\003\181\003\181\t\174\003\181\014\242\n\006\003\181\011\238\003\181\003\181\015\194\003\181\003\181\003\181\003\181\003\181\003\181\003\181\003\181\003\181\003\181\003\181\003\181\003\181\r&\003\181\003\181\003\181\003\181\003\181\t\201\bZ\004>\004>\002^\t\201\t\201\t\201\t\201\012\186\0202\t\201\t\201\t\201\t\201\000\238\t\201\t\201\015\202\t\201\t\201\t\201\007\214\t\201\t\201\t\201\t\201\006\001\t\201\004j\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\005~\t\201\007\254\t\201\007V\t\201\t\201\t\201\t\201\t\201\0036\004i\t\201\t\201\t\201\000\238\t\201\021\218\t\201\t\201\t\201\004V\007\230\t\201\t\201\t\201\t\201\t\201\t\201\t\201\tn\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\005&\t\201\t\201\026B\t\201\t\201\t\201\006\222\024\226\015*\000\238\003\169\t\201\t\201\t\201\t\201\t\201\t\201\018^\t\201\t\201\t\201\t\201\t\201\t\201\t\201\0206\t\201\t\201\0156\t\201\t\201\004i\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\t\201\000\238\t\217\t\201\t\201\t\201\t\201\t\217\t\217\t\217\t\217\018f\003\146\t\217\t\217\t\217\t\217\004N\t\217\t\217\005\249\t\217\t\217\t\217\004i\t\217\t\217\t\217\t\217\006\014\t\217\004\234\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\006\189\t\217\003\169\t\217\022\214\t\217\t\217\t\217\t\217\t\217\026F\b\241\t\217\t\217\t\217\r2\t\217\021\238\t\217\t\217\t\217\004Z\006\198\t\217\t\217\t\217\t\217\t\217\t\217\t\217\006&\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\202\t\217\t\217\t\210\t\217\t\217\t\217\001V\004>\005\189\000\238\022\222\t\217\t\217\t\217\t\217\t\217\t\217\006b\t\217\t\217\t\217\t\217\t\217\t\217\t\217\006z\t\217\t\217\001Z\t\217\t\217\b\241\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\t\217\b\193\t\209\t\217\t\217\t\217\t\217\t\209\t\209\t\209\t\209\005\189\028\023\t\209\t\209\t\209\t\209\007-\t\209\t\209\004J\t\209\t\209\t\209\b\241\t\209\t\209\t\209\t\209\014\230\t\209\005\189\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\006\150\t\209\000\238\t\209\004\209\t\209\t\209\t\209\t\209\t\209\n:\007%\t\209\t\209\t\209\007%\t\209\022\002\t\209\t\209\t\209\001\006\007\206\t\209\t\209\t\209\t\209\t\209\t\209\t\209\006\178\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\001f\t\209\t\209\006\158\t\209\t\209\t\209\006\253\006\194\b\193\007\021\006\230\t\209\t\209\t\209\t\209\t\209\t\209\011.\t\209\t\209\t\209\t\209\t\209\t\209\t\209\006\210\t\209\t\209\019\162\t\209\t\209\002^\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\t\209\005^\t\189\t\209\t\209\t\209\t\209\t\189\t\189\t\189\t\189\000\238\b\026\t\189\t\189\t\189\t\189\002^\t\189\t\189\012r\t\189\t\189\t\189\023\206\t\189\t\189\t\189\t\189\007\021\t\189\0036\t\189\t\189\t\189\t\189\t\189\t\189\t\189\t\189\nJ\t\189\b\154\t\189\t\146\t\189\t\189\t\189\t\189\t\189\012\178\025f\t\189\t\189\t\189\006\141\t\189\022\026\t\189\t\189\t\189\0036\004\146\t\189\t\189\t\189\t\189\t\189\t\189\t\189\001\162\t\189\t\189\t\189\t\189\t\189\t\189\t\189\t\189\t\189\t\189\t\189\001f\t\189\t\189\007\018\t\189\t\189\t\189\002*\011.\018>\026*\007*\t\189\t\189\t\189\t\189\t\189\t\189\012z\t\189\t\189\t\189\t\189\t\189\t\189\t\189\t\202\t\189\t\189\t\210\t\189\t\189\002j\t\189\t\189\t\189\t\189\t\189\t\189\t\189\t\189\t\189\t\189\t\189\t\189\t\189\b\189\t\197\t\189\t\189\t\189\t\189\t\197\t\197\t\197\t\197\t\194\t\234\t\197\t\197\t\197\t\197\t\202\t\197\t\197\t\210\t\197\t\197\t\197\011\146\t\197\t\197\t\197\t\197\000\238\t\197\012r\t\197\t\197\t\197\t\197\t\197\t\197\t\197\t\197\004\129\t\197\000\238\t\197\007b\t\197\t\197\t\197\t\197\t\197\006\"\007\021\t\197\t\197\t\197\007\021\t\197\022.\t\197\t\197\t\197\015\146\011B\t\197\t\197\t\197\t\197\t\197\t\197\t\197\007\234\t\197\t\197\t\197\t\197\t\197\t\197\t\197\t\197\t\197\t\197\t\197\007~\t\197\t\197\012\238\t\197\t\197\t\197\003\149\004\129\b\189\015\206\bN\t\197\t\197\t\197\t\197\t\197\t\197\002^\t\197\t\197\t\197\t\197\t\197\t\197\t\197\012r\t\197\t\197\012\222\t\197\t\197\002j\t\197\t\197\t\197\t\197\t\197\t\197\t\197\t\197\t\197\t\197\t\197\t\197\t\197\b\154\t\193\t\197\t\197\t\197\t\197\t\193\t\193\t\193\t\193\002^\006\005\t\193\t\193\t\193\t\193\r\150\t\193\t\193\015\198\t\193\t\193\t\193\003\014\t\193\t\193\t\193\t\193\006\t\t\193\t\002\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\015\242\t\193\015\250\t\193\t\198\t\193\t\193\t\193\t\193\t\193\015\178\t\230\t\193\t\193\t\193\014Z\t\193\022B\t\193\t\193\t\193\rJ\b%\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\242\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\004>\t\193\t\193\b\217\t\193\t\193\t\193\b!\n\002\018\134\016:\000\238\t\193\t\193\t\193\t\193\t\193\t\193\003\t\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\202\t\193\t\193\t\210\t\193\t\193\015\138\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\t\193\000\238\t\205\t\193\t\193\t\193\t\193\t\205\t\205\t\205\t\205\000\238\027\174\t\205\t\205\t\205\t\205\n\018\t\205\t\205\018b\t\205\t\205\t\205\012j\t\205\t\205\t\205\t\205\012\169\t\205\012\134\t\205\t\205\t\205\t\205\t\205\t\205\t\205\t\205\014:\t\205\018j\t\205\016\130\t\205\t\205\t\205\t\205\t\205\b\217\012\138\t\205\t\205\t\205\016B\t\205\022^\t\205\t\205\t\205\019\014\b\021\t\205\t\205\t\205\t\205\t\205\t\205\t\205\019\006\t\205\t\205\t\205\t\205\t\205\t\205\t\205\t\205\t\205\t\205\t\205\021\146\t\205\t\205\003\142\t\205\t\205\t\205\005\253\022N\012r\012\181\003\142\t\205\t\205\t\205\t\205\t\205\t\205\012\182\t\205\t\205\t\205\t\205\t\205\t\205\t\205\b\025\t\205\t\205\000\238\t\205\t\205\000\238\t\205\t\205\t\205\t\205\t\205\t\205\t\205\t\205\t\205\t\205\t\205\t\205\t\205\019\174\t\221\t\205\t\205\t\205\t\205\t\221\t\221\t\221\t\221\019\202\020\022\t\221\t\221\t\221\t\221\018\194\t\221\t\221\019>\t\221\t\221\t\221\023j\t\221\t\221\t\221\t\221\024Z\t\221\003\254\t\221\t\221\t\221\t\221\t\221\t\221\t\221\t\221\b\026\t\221\025\238\t\221\025\006\t\221\t\221\t\221\t\221\t\221\012\210\023B\t\221\t\221\t\221\t\025\t\221\022r\t\221\t\221\t\221\011.\012\214\t\221\t\221\t\221\t\221\t\221\t\221\t\221\012\254\t\221\t\221\t\221\t\221\t\221\t\221\t\221\t\221\t\221\t\221\t\221\r\018\t\221\t\221\026&\t\221\t\221\t\221\006^\rR\016B\rb\t\001\t\221\t\221\t\221\t\221\t\221\t\221\r\170\t\221\t\221\t\221\t\221\t\221\t\221\t\221\005\t\t\221\t\221\b\150\t\221\t\221\023n\t\221\t\221\t\221\t\221\t\221\t\221\t\221\t\221\t\221\t\221\t\221\t\221\t\221\r\246\t\213\t\221\t\221\t\221\t\221\t\213\t\213\t\213\t\213\000\238\027\018\t\213\t\213\t\213\t\213\t\005\t\213\t\213\014\022\t\213\t\213\t\213\0146\t\213\t\213\t\213\t\213\000\238\t\213\014~\t\213\t\213\t\213\t\213\t\213\t\213\t\213\t\213\014\250\t\213\015\018\t\213\024\250\t\213\t\213\t\213\t\213\t\213\0266\015\154\t\213\t\213\t\213\000\238\t\213\022\134\t\213\t\213\t\213\015\158\025\014\t\213\t\213\t\213\t\213\t\213\t\213\t\213\002^\t\213\t\213\t\213\t\213\t\213\t\213\t\213\t\213\t\213\t\213\t\213\015\214\t\213\t\213\015\218\t\213\t\213\t\213\016\002\016\006\016\030\016\150\016\198\t\213\t\213\t\213\t\213\t\213\t\213\004\129\t\213\t\213\t\213\t\213\t\213\t\213\t\213\016\202\t\213\t\213\016\238\t\213\t\213\026\190\t\213\t\213\t\213\t\213\t\213\t\213\t\213\t\213\t\213\t\213\t\213\t\213\t\213\016\242\n\025\t\213\t\213\t\213\t\213\n\025\n\025\n\025\n\025\017\002\017\018\n\025\n\025\n\025\n\025\011\146\n\025\n\025\017\030\n\025\n\025\n\025\017R\n\025\n\025\n\025\n\025\017V\n\025\017\166\n\025\n\025\n\025\n\025\n\025\n\025\n\025\n\025\017\206\n\025\017\210\n\025\018\022\n\025\n\025\n\025\n\025\n\025\018:\018J\n\025\n\025\n\025\018r\n\025\022\146\n\025\n\025\n\025\018v\018\130\n\025\n\025\n\025\n\025\n\025\n\025\n\025\018\146\n\025\n\025\n\025\n\025\n\025\n\025\n\025\n\025\n\025\n\025\n\025\018\170\n\025\n\025\018\186\n\025\n\025\n\025\018\206\018\230\019\022\019\026\019&\n\025\n\025\n\025\n\025\n\025\n\025\0196\n\025\n\025\n\025\n\025\n\025\n\025\n\025\003\173\n\025\n\025\019J\n\025\n\025\020>\n\025\n\025\n\025\n\025\n\025\n\025\n\025\n\025\n\025\n\025\n\025\n\025\n\025\020J\t\177\n\025\n\025\n\025\n\025\t\177\t\177\t\177\t\177\020z\020\158\t\177\t\177\t\177\t\177\020\198\t\177\t\177\021N\t\177\t\177\t\177\000\238\t\177\t\177\t\177\t\177\021b\t\177\021j\t\177\t\177\t\177\t\177\t\177\t\177\t\177\t\177\021~\t\177\021\138\t\177\021\158\t\177\t\177\t\177\t\177\t\177\021\182\021\194\t\177\t\177\t\177\021\214\t\177\003\173\t\177\t\177\t\177\021\234\021\254\t\177\t\177\t\177\t\177\t\177\t\177\t\177\022\022\t\177\t\177\t\177\t\177\t\177\t\177\t\177\t\177\t\177\t\177\t\177\022*\t\166\t\254\004%\t\177\t\177\t\177\015\238\022>\015\130\022Z\022n\t\177\t\177\t\177\t\177\t\177\t\177\007\234\t\177\t\177\t\177\t\177\t\177\t\174\t\177\022\130\n\006\t\177\022\166\t\177\t\177\015\246\t\177\t\177\t\177\t\177\t\177\t\177\t\177\t\177\t\177\t\177\t\177\t\177\t\177\000\238\t\177\t\177\t\177\t\177\t\177\002\t\022\178\b\029\022\190\012\161\002\t\001\002\001\006\002\t\027\178\002j\001\"\002\t\t\190\002\t\022\242\001&\002\t\012\161\002\t\002\t\002\t\023\002\002\t\002\t\002\t\001*\004%\t\238\023\018\001.\002\t\002\t\002\t\002\t\002\t\t\246\002\t\t\178\0012\023\030\003z\023R\002\t\002\t\002\t\002\t\002\t\023z\023\130\003\206\002N\002\t\022\170\002\t\022\182\002\t\002\t\003F\023\138\023\146\003\214\002\t\002\t\002\t\b\142\b\146\b\158\023\166\019\214\005n\002\t\002\t\002\t\002\t\002\t\002\t\002\t\002\t\002\t\023\174\t\166\t\254\023\194\002\t\002\t\002\t\023\242\024\030\0246\024N\024j\005z\002\t\005~\002\t\002\t\002\t\024r\002\t\002\t\002\t\002\t\b\166\021\202\b\170\024\162\022\n\002\t\024\194\002\t\002\t\024\222\002\t\002\t\002\t\002\t\002\t\002\t\005\130\b\186\002\t\002\t\002\t\t2\004j\024\242\n\005\002\t\002\t\002\t\002\t\n\005\001\002\001\006\n\005\025\026\025:\001\"\n\005\n\005\n\005\025n\001&\n\005\025v\n\005\n\005\n\005\025\130\n\005\n\005\n\005\001*\025\226\n\005\026\018\001.\n\005\n\005\n\005\n\005\n\005\n\005\n\005\021\150\0012\026\026\003z\026V\n\005\n\005\n\005\n\005\n\005\026n\026\198\003\206\002N\n\005\021\174\n\005\021\186\n\005\n\005\003F\026\218\026\246\003\214\n\005\n\005\n\005\b\142\b\146\b\158\027\030\n\005\005n\n\005\n\005\n\005\n\005\n\005\n\005\n\005\n\005\n\005\027&\n\005\n\005\027N\n\005\n\005\n\005\027V\027^\027j\027r\027{\005z\n\005\005~\n\005\n\005\n\005\027\139\n\005\n\005\n\005\n\005\b\166\n\005\b\170\027\158\n\005\n\005\027\186\n\005\n\005\027\215\n\005\n\005\n\005\n\005\n\005\n\005\005\130\b\186\n\005\n\005\n\005\t2\004j\027\231\n\001\n\005\n\005\n\005\n\005\n\001\001\002\001\006\n\001\028\003\028W\001\"\n\001\n\001\n\001\028s\001&\n\001\028~\n\001\n\001\n\001\028\179\n\001\n\001\n\001\001*\028\199\n\001\028\207\001.\n\001\n\001\n\001\n\001\n\001\n\001\n\001\021\206\0012\029\011\003z\029\019\n\001\n\001\n\001\n\001\n\001\000\000\000\000\003\206\002N\n\001\021\226\n\001\021\246\n\001\n\001\003F\000\000\000\000\003\214\n\001\n\001\n\001\b\142\b\146\b\158\000\000\n\001\005n\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\n\001\000\000\n\001\n\001\000\000\n\001\n\001\n\001\000\000\000\000\000\000\000\000\000\000\005z\n\001\005~\n\001\n\001\n\001\000\000\n\001\n\001\n\001\n\001\b\166\n\001\b\170\000\000\n\001\n\001\000\000\n\001\n\001\000\000\n\001\n\001\n\001\n\001\n\001\n\001\005\130\b\186\n\001\n\001\n\001\t2\004j\000\000\002I\n\001\n\001\n\001\n\001\002I\001\002\001\006\002I\000\000\000\000\001\"\002I\t\190\002I\004i\001&\002I\000\000\002I\002I\002I\000\000\002I\002I\002I\001*\004i\t\238\000\000\001.\002I\002I\002I\002I\002I\t\246\002I\022R\0012\000\000\003z\004\218\002I\002I\002I\002I\002I\000\000\000\000\003\206\002N\002I\022f\002I\022z\002I\002I\003F\000\238\000\000\003\214\002I\002I\002I\b\142\b\146\b\158\000\238\019\214\005n\002I\002I\002I\002I\002I\002I\002I\002I\002I\000\000\004i\002I\000\000\002I\002I\002I\019\002\004i\000\000\004i\000\000\005z\002I\005~\002I\002I\002I\000\000\002I\002I\002I\002I\b\166\000\000\b\170\004i\000\000\002I\000\000\002I\002I\019\n\002I\002I\002I\002I\002I\002I\005\130\b\186\002I\002I\002I\t2\004j\004i\004i\002I\002I\002I\002I\004i\004i\b\021\004i\004i\004i\004i\004i\004i\004i\004i\000\000\004i\000\238\004i\004i\004i\004i\004i\004i\000\000\004i\004i\004i\004i\004i\004i\004i\004i\004i\000\000\004i\004i\000\238\000\238\004i\004i\000\000\004i\004i\004i\004i\004i\004i\004i\004i\004i\004i\004i\004i\004i\004i\004i\004i\006j\004i\004i\004i\004i\004i\004i\004i\004i\000\238\004i\004i\004i\004i\004i\004i\004i\004i\004i\019\150\004i\000\000\004i\004i\004i\004i\004i\004i\000\238\004i\000\n\004i\004i\004i\004i\004i\004i\004i\000\000\004i\004i\004i\000\000\000\238\004i\004i\002\237\002\237\004i\000\238\004i\004i\000\000\004i\004i\000\000\004i\012\170\000\000\000\000\002\237\001\"\000\000\004i\004i\004i\000\000\000\238\004i\004i\004i\004i\000\169\000\169\004i\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\000\000\169\000\000\000\169\000\169\019j\000\169\000\169\000\000\0062\000\169\000\169\005\222\000\169\000\169\000\169\000\169\012\174\000\169\006F\000\169\000\169\000\000\006N\000\169\000\169\018.\000\169\000\169\000\169\007\138\000\169\012\186\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\003\146\018\158\000\169\000\169\000\000\001\006\000\169\000\169\b>\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\000\169\005~\002\237\000\169\000\000\t\029\000\169\000\000\000\169\000\000\000\169\000\000\000\000\000\000\b\006\000\169\000\169\000\169\000\169\000\169\000\169\007\r\000\169\000\169\000\169\007\r\tN\002N\000\169\000\n\r\198\000\169\003\134\000\169\000\238\000\222\000\000\022\246\000\000\000\169\000\000\023\006\023\022\023\"\000\000\000\169\000\169\000\169\000\169\bZ\002A\000\169\000\169\000\169\000\169\002A\001\002\001\006\002A\002\237\000\000\001\"\002A\000\238\002A\000\000\001&\002A\000\000\002A\002A\002A\000\000\002A\002A\002A\001*\000\000\024\134\000\000\001.\002A\002A\002A\002A\002A\000\000\002A\000\000\0012\000\000\003z\000\000\002A\002A\002A\002A\002A\007\r\000\000\003\206\b\162\002A\000\000\002A\000\000\002A\002A\003F\000\000\000\000\003\214\002A\002A\002A\b\142\b\146\b\158\004\022\014\150\005n\002A\002A\002A\002A\002A\002A\002A\002A\002A\000\000\t\166\t\254\000\000\002A\002A\002A\000\000\000\000\000\000\004!\000\000\005z\002A\005~\002A\002A\002A\000\000\002A\002A\002A\002A\b\166\t\174\b\170\000\000\n\006\002A\000\000\002A\002A\001\006\002A\002A\002A\002A\002A\002A\005\130\b\186\002A\002A\002A\t2\004j\000\000\002U\002A\002A\002A\002A\002U\000\238\025R\002U\000\000\000\000\000\000\002U\000\000\002U\000\000\000\000\002U\000\000\002U\002U\002U\000\000\002U\002U\002U\000\000\000\000\001\186\002N\000\000\002U\002U\002U\002U\002U\bZ\002U\000\000\004!\000\000\028c\000\000\002U\002U\002U\002U\002U\000\000\000\000\000\238\000\000\002U\000\000\002U\0062\002U\002U\005\222\007\002\000\000\000\000\002U\002U\002U\006F\012\170\000\000\000\000\006N\001\"\002U\002U\002U\002U\002U\002U\002U\002U\002U\000\000\t\166\t\254\000\000\002U\002U\002U\000\000\r\234\000\000\000\000\000\000\002\237\002U\003\146\002U\002U\002U\000\000\002U\002U\002U\002U\025V\t\174\000\000\000\000\n\006\002U\012\174\002U\002U\007\138\002U\002U\002U\002U\002U\002U\000\n\000\000\002U\002U\002U\012\186\000\000\014\014\002Q\002U\002U\002U\002U\002Q\bF\003\146\002Q\002\237\001\186\002N\002Q\000\000\002Q\0051\000\000\002Q\000\000\002Q\002Q\002Q\002\237\002Q\002Q\002Q\005~\000\000\0051\b\006\000\000\002Q\002Q\002Q\002Q\002Q\000\000\002Q\014\026\007\138\000\000\000\000\000\000\002Q\002Q\002Q\002Q\002Q\007\138\000\238\005\182\000\000\002Q\000\000\002Q\r\178\002Q\002Q\000\000\0051\br\003\246\002Q\002Q\002Q\006n\012\170\004\002\000\000\tv\001\"\002Q\002Q\002Q\002Q\002Q\002Q\002Q\002Q\002Q\000\000\t\166\t\254\b\006\002Q\002Q\002Q\000\000\000\000\000\000\0051\000\000\b\006\002Q\0051\002Q\002Q\002Q\000\000\002Q\002Q\002Q\002Q\000\238\t\174\000\000\000\000\n\006\002Q\012\174\002Q\002Q\000\238\002Q\002Q\002Q\002Q\002Q\002Q\000\000\000\000\002Q\002Q\002Q\012\186\003B\r\238\002E\002Q\002Q\002Q\002Q\002E\000\000\003\146\002E\000\000\000\000\028G\002E\000\000\002E\000\000\000\000\002E\000\000\002E\002E\002E\000\000\002E\002E\002E\005~\000\000\000\000\000\000\000\000\002E\002E\002E\002E\002E\000\000\002E\r\250\007\138\000\000\000\000\000\000\002E\002E\002E\002E\002E\007\138\000\000\tN\023^\002E\000\000\002E\r\178\002E\002E\000\000\000\000\025^\022\246\002E\002E\002E\023\006\023\022\023\"\000\000\025\154\000\000\002E\002E\002E\002E\002E\002E\002E\002E\002E\000\000\t\166\t\254\b\006\002E\002E\002E\000\000\000\000\000\000\006.\000\000\b\006\002E\000\000\002E\002E\002E\000\000\002E\002E\002E\002E\000\238\t\174\007\138\000\000\n\006\002E\000\000\002E\002E\000\238\002E\002E\002E\002E\002E\002E\000\000\b\021\002E\002E\002E\b\021\000\000\025\166\002M\002E\002E\002E\002E\002M\000\238\000\000\002M\000\000\000\000\000\000\002M\000\000\002M\014:\000\000\002M\000\000\002M\002M\002M\b\006\002M\002M\002M\012\025\012\025\000\000\000\000\012\025\002M\002M\002M\002M\002M\b\021\002M\000\000\t.\000\000\000\000\000\238\002M\002M\002M\002M\002M\000\000\000\000\000\000\b\021\002M\000\000\002M\0062\002M\002M\005\222\006:\000\000\027\006\002M\002M\002M\006F\000\000\012I\000\000\006N\000\238\002M\002M\002M\002M\002M\002M\002M\002M\002M\b\021\000\000\002M\000\000\002M\002M\002M\000\000\012I\000\000\000\000\002\194\025\170\002M\002\198\002M\002M\002M\000\000\002M\002M\002M\002M\012\025\000\238\007\138\000\000\002\210\002M\b\021\002M\002M\000\000\n\026\002M\002M\002M\002M\002M\t\026\t\218\002M\002M\002M\007\138\b\189\025\178\t%\002M\002M\002M\002M\t%\000\000\001\162\t%\002\222\023\150\001\"\t%\000\000\t%\000\000\000\000\nV\026\230\t%\nz\t%\b\006\t%\t%\t%\0062\000\000\000\000\005\222\027\n\n\142\n\166\n\174\n\150\n\182\006F\t%\000\000\000\238\006N\b\006\000\238\t%\t%\n\190\n\198\t%\000\000\012\170\027\150\002j\t%\001\"\t%\000\000\n\206\t%\002\226\002\237\000\000\000\238\t%\t%\000\238\012\186\000\000\000\000\000\000\000\000\000\000\t%\t%\n^\n\158\n\214\n\222\n\238\t%\t%\000\000\000\000\t%\000\000\t%\t%\n\246\000\000\b\189\000\n\000\000\000\000\012\174\t%\005~\t%\t%\n\254\b\241\t%\t%\t%\t%\000\000\007\181\007\138\002\237\012\186\t%\000\000\t%\t%\000\000\011\030\t%\011&\n\230\t%\t%\002\237\002\237\t%\011\006\t%\000\000\000\000\026\254\002\129\t%\t%\011\014\011\022\002\129\ne\000\000\002\129\005~\007\181\000\000\002\129\000\000\002\129\000\000\000\000\002\129\000\000\002\129\002\129\002\129\b\006\002\129\002\129\002\129\007\181\000\000\000\000\007\181\t\138\002\129\002\129\002\129\002\129\002\129\007\181\002\129\026v\ne\007\181\000\000\000\238\002\129\002\129\002\129\002\129\002\129\000\000\b\169\000\000\000\000\002\129\000\000\002\129\ne\002\129\002\129\ne\011:\000\000\000\000\002\129\002\129\002\129\ne\000\000\000\000\000\000\ne\000\000\002\129\002\129\n^\002\129\002\129\002\129\002\129\002\129\002\129\000\000\000\000\002\129\000\000\002\129\002\129\002\129\000\000\000\000\001&\b\169\000\000\000\000\002\129\000\000\002\129\002\129\002\129\000\000\002\129\002\129\002\129\002\129\000\000\000\000\000\000\001F\000\000\002\129\000\000\002\129\002\129\b\169\002\129\002\129\002\129\002\129\002\129\002\129\001R\000\000\002\129\002\129\002\129\000\000\000\000\000\000\002i\002\129\002\129\002\129\002\129\002i\000\000\000\000\002i\000\000\000\000\000\000\002i\000\000\002i\000\000\005n\002i\000\000\002i\002i\002i\b\169\002i\002i\002i\004\246\000\000\000\000\b\169\000\000\002i\002i\002i\002i\002i\002^\002i\005z\000\000\000\000\000\000\000\000\002i\002i\002i\002i\002i\000\000\b\165\000\000\000\000\002i\000\000\002i\001*\002i\002i\000\000\000\000\000\000\023*\002i\002i\002i\005\130\000\000\000\000\015\162\000\000\000\000\002i\002i\n^\002i\002i\002i\002i\002i\002i\0036\000\000\002i\016\026\002i\002i\002i\003F\000\000\000\000\b\165\000\000\000\000\002i\0162\002i\002i\002i\000\000\002i\002i\002i\002i\000\000\000\000\000\000\000\000\000\000\002i\000\000\002i\002i\b\165\002i\002i\002i\002i\002i\002i\000\000\0075\002i\002i\002i\0075\000\000\000\000\002u\002i\002i\002i\002i\002u\000\238\000\000\002u\000\000\000\000\000\000\002u\000\000\002u\t\166\t\254\nV\000\000\002u\002u\002u\b\165\002u\002u\002u\004\246\000\000\000\000\b\165\000\000\002u\002u\002u\n\150\002u\000\000\002u\t\174\011N\000\000\n\006\000\000\002u\002u\002u\002u\002u\000\000\000\000\000\000\000\000\002u\000\000\002u\011V\002u\002u\011^\000\000\000\000\000\000\002u\002u\002u\011f\000\000\000\000\000\000\011n\0075\002u\002u\n^\n\158\002u\002u\002u\002u\002u\000\000\000\000\002u\000\000\002u\002u\002u\t\202\000\000\000\000\t\210\000\000\000\000\002u\000\000\002u\002u\002u\000\000\002u\002u\002u\002u\000\000\000\238\000\000\000\000\000\000\002u\000\000\002u\002u\000\000\002u\002u\002u\002u\002u\002u\000\000\000\000\002u\002u\002u\000\000\000\000\000\000\002\133\002u\002u\002u\002u\002\133\007\201\000\000\002\133\000\000\007\177\000\000\002\133\000\000\002\133\002^\000\000\002\133\000\000\002\133\002\133\002\133\000\000\002\133\002\133\002\133\007\177\000\000\026\002\005\222\000\000\002\133\002\133\002\133\002\133\002\133\007\177\002\133\000\000\007\201\007\177\000\000\000\000\002\133\002\133\002\133\002\133\002\133\000\000\000\000\000\000\000\000\002\133\000\000\002\133\007\201\002\133\002\133\005\222\0036\000\000\000\000\002\133\002\133\002\133\007\201\000\000\000\000\000\000\007\201\000\000\002\133\002\133\n^\002\133\002\133\002\133\002\133\002\133\002\133\000\000\000\000\002\133\000\000\002\133\002\133\002\133\000\000\000\000\000\000\004\146\000\000\000\000\002\133\005\r\002\133\002\133\002\133\000\000\002\133\002\133\002\133\002\133\000\000\000\238\000\000\000\000\000\000\002\133\000\000\002\133\002\133\000\000\002\133\002\133\002\133\002\133\002\133\002\133\000\000\000\000\002\133\002\133\002\133\000\000\000\000\000\000\002e\002\133\002\133\002\133\002\133\002e\007\217\000\000\002e\000\000\007\221\000\000\002e\000\000\002e\000\000\000\000\002e\000\000\002e\002e\002e\000\000\002e\002e\002e\0062\000\000\000\000\005\222\000\000\002e\002e\002e\002e\002e\007\221\002e\000\000\007\217\007\221\000\000\000\000\002e\002e\002e\002e\002e\000\000\000\000\000\000\000\000\002e\000\000\002e\011\130\002e\002e\007\217\000\000\000\000\000\000\002e\002e\002e\007\217\000\000\000\000\000\000\007\217\000\000\002e\002e\n^\002e\002e\002e\002e\002e\002e\000\000\000\000\002e\000\000\002e\002e\002e\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\000\002e\002e\002e\000\000\002e\002e\002e\002e\000\000\000\238\000\000\000\000\000\000\002e\000\000\002e\002e\000\000\002e\002e\002e\002e\002e\002e\000\000\000\000\002e\002e\002e\000\000\000\000\000\000\002q\002e\002e\002e\002e\002q\000\238\000\000\002q\000\000\007\173\000\000\002q\000\000\002q\000\000\000\000\nV\000\000\002q\002q\002q\000\000\002q\002q\002q\007\173\000\000\000\000\005\222\000\000\002q\002q\002q\n\150\002q\007\173\002q\000\000\022\202\007\173\000\000\000\000\002q\002q\002q\002q\002q\000\000\000\000\000\000\000\000\002q\000\000\002q\011V\002q\002q\011^\000\000\000\000\000\000\002q\002q\002q\011f\000\000\000\000\000\000\011n\000\000\002q\002q\n^\n\158\002q\002q\002q\002q\002q\000\000\000\000\002q\000\000\002q\002q\002q\000\000\000\000\000\000\012!\012!\000\000\002q\012!\002q\002q\002q\000\000\002q\002q\002q\002q\000\000\000\000\012\029\012\029\000\000\002q\012\029\002q\002q\000\000\002q\002q\002q\002q\002q\002q\000\000\000\000\002q\002q\002q\000\000\000\000\000\000\002m\002q\002q\002q\002q\002m\002\237\000\238\002m\000\000\015v\000\000\002m\000\000\002m\000\000\000\000\nV\000\000\002m\002m\002m\000\238\002m\002m\002m\b\t\000\000\000\000\000\000\b\t\002m\002m\002m\n\150\002m\000\n\002m\000\000\000\000\012!\000\000\000\000\002m\002m\002m\002m\002m\000\000\000\000\000\000\000\000\002m\002\237\002m\012\029\002m\002m\000\000\000\000\000\000\007\017\002m\002m\002m\007\017\002\237\002\237\000\000\000\000\b\t\002m\002m\n^\n\158\002m\002m\002m\002m\002m\000\000\000\000\002m\000\000\002m\002m\002m\000\000\000\000\000\000\000\000\000\000\b\t\002m\000\000\002m\002m\002m\000\000\002m\002m\002m\002m\000\000\000\000\000\238\000\000\000\000\002m\000\000\002m\002m\000\000\002m\002m\002m\002m\002m\002m\000\000\000\000\002m\002m\002m\000\000\000\000\000\000\002\149\002m\002m\002m\002m\002\149\004\246\001\006\002\149\000\000\000\000\007\017\002\149\000\000\002\149\000\000\000\000\nV\000\000\002\149\002\149\002\149\000\000\002\149\002\149\002\149\b\005\000\000\000\000\000\000\b\005\n\142\n\166\n\174\n\150\n\182\000\000\002\149\000\000\000\000\000\000\000\000\000\000\002\149\002\149\n\190\n\198\002\149\000\000\000\000\n\n\003\134\002\149\000\000\002\149\000\000\n\206\002\149\000\000\000\000\000\000\000\000\002\149\002\149\000\238\021v\000\000\021\130\000\000\000\000\b\005\002\149\002\149\n^\n\158\n\214\n\222\n\238\002\149\002\149\000\000\000\000\002\149\000\000\002\149\002\149\n\246\000\000\000\000\000\000\000\000\000\000\b\005\002\149\000\000\002\149\002\149\n\254\000\000\002\149\002\149\002\149\002\149\000\000\000\000\000\000\000\000\000\000\002\149\000\000\002\149\002\149\000\000\002\149\002\149\002\149\n\230\002\149\002\149\000\000\000\000\002\149\011\006\002\149\000\000\000\000\000\000\002}\002\149\002\149\011\014\011\022\002}\004\246\001\006\002}\000\000\000\000\000\000\002}\000\000\002}\000\000\000\000\nV\000\000\002}\002}\002}\000\000\002}\002}\002}\000\000\000\000\000\000\000\000\000\000\002}\002}\002}\n\150\002}\000\000\002}\000\000\000\000\000\000\000\000\000\000\002}\002}\002}\002}\002}\000\000\000\000\022\014\003\134\002}\000\000\002}\000\000\002}\002}\000\000\000\000\000\000\000\000\002}\002}\002}\022\"\000\000\0226\000\000\000\000\000\000\002}\002}\n^\n\158\002}\002}\002}\002}\002}\000\000\000\000\002}\000\000\002}\002}\002}\000\000\000\000\000\000\000\000\000\000\000\000\002}\000\000\002}\002}\002}\000\000\002}\002}\002}\002}\000\000\000\000\000\000\000\000\000\000\002}\000\000\002}\002}\000\000\002}\002}\002}\002}\002}\002}\000\000\000\000\002}\002}\002}\000\000\000\000\000\000\002y\002}\002}\002}\002}\002y\000\000\000\000\002y\000\000\000\000\000\000\002y\000\000\002y\000\000\000\000\nV\000\000\002y\002y\002y\000\000\002y\002y\002y\000\000\000\000\000\000\000\000\000\000\002y\002y\002y\n\150\002y\000\000\002y\000\000\000\000\000\000\000\000\000\000\002y\002y\002y\002y\002y\000\000\000\000\000\000\000\000\002y\000\000\002y\000\000\002y\002y\000\000\000\000\000\000\000\000\002y\002y\002y\000\000\000\000\000\000\000\000\000\000\000\000\002y\002y\n^\n\158\002y\002y\002y\002y\002y\000\000\000\000\002y\000\000\002y\002y\002y\000\000\000\000\000\000\000\000\000\000\000\000\002y\000\000\002y\002y\002y\000\000\002y\002y\002y\002y\000\000\000\000\000\000\000\000\000\000\002y\000\000\002y\002y\000\000\002y\002y\002y\002y\002y\002y\000\000\000\000\002y\002y\002y\000\000\000\000\000\000\002\141\002y\002y\002y\002y\002\141\000\000\000\000\002\141\000\000\000\000\000\000\002\141\000\000\002\141\000\000\000\000\nV\000\000\002\141\002\141\002\141\000\000\002\141\002\141\002\141\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\002\141\000\000\002\141\000\000\000\000\000\000\000\000\000\000\002\141\002\141\n\190\n\198\002\141\000\000\000\000\000\000\000\000\002\141\000\000\002\141\000\000\002\141\002\141\000\000\000\000\000\000\000\000\002\141\002\141\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\141\002\141\n^\n\158\n\214\n\222\002\141\002\141\002\141\000\000\000\000\002\141\000\000\002\141\002\141\002\141\000\000\000\000\000\000\000\000\000\000\000\000\002\141\000\000\002\141\002\141\002\141\000\000\002\141\002\141\002\141\002\141\000\000\000\000\000\000\000\000\000\000\002\141\000\000\002\141\002\141\000\000\002\141\002\141\002\141\n\230\002\141\002\141\000\000\000\000\002\141\002\141\002\141\000\000\000\000\000\000\002a\002\141\002\141\002\141\002\141\002a\000\000\000\000\002a\000\000\000\000\000\000\002a\000\000\002a\000\000\000\000\nV\000\000\002a\002a\002a\000\000\002a\002a\002a\000\000\000\000\000\000\000\000\000\000\002a\002a\002a\n\150\002a\000\000\002a\000\000\000\000\000\000\000\000\000\000\002a\002a\002a\002a\002a\000\000\000\000\000\000\000\000\002a\000\000\002a\000\000\002a\002a\000\000\000\000\000\000\000\000\002a\002a\002a\000\000\000\000\000\000\000\000\000\000\000\000\002a\002a\n^\n\158\002a\002a\002a\002a\002a\000\000\000\000\002a\000\000\002a\002a\002a\000\000\000\000\000\000\000\000\000\000\000\000\002a\000\000\002a\002a\002a\000\000\002a\002a\002a\002a\000\000\000\000\000\000\000\000\000\000\002a\000\000\002a\002a\000\000\002a\002a\002a\002a\002a\002a\000\000\000\000\002a\002a\002a\000\000\000\000\000\000\002]\002a\002a\002a\002a\002]\000\000\000\000\002]\000\000\000\000\000\000\002]\000\000\002]\000\000\000\000\nV\000\000\002]\002]\002]\000\000\002]\002]\002]\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\002]\000\000\002]\000\000\000\000\000\000\000\000\000\000\002]\002]\n\190\n\198\002]\000\000\000\000\000\000\000\000\002]\000\000\002]\000\000\002]\002]\000\000\000\000\000\000\000\000\002]\002]\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002]\002]\n^\n\158\n\214\n\222\002]\002]\002]\000\000\000\000\002]\000\000\002]\002]\002]\000\000\000\000\000\000\000\000\000\000\000\000\002]\000\000\002]\002]\002]\000\000\002]\002]\002]\002]\000\000\000\000\000\000\000\000\000\000\002]\000\000\002]\002]\000\000\002]\002]\002]\n\230\002]\002]\000\000\000\000\002]\002]\002]\000\000\000\000\000\000\002\185\002]\002]\002]\002]\002\185\000\000\000\000\002\185\000\000\000\000\000\000\002\185\000\000\002\185\000\000\000\000\nV\000\000\002\185\002\185\002\185\000\000\002\185\002\185\002\185\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\002\185\000\000\002\185\000\000\000\000\000\000\000\000\000\000\002\185\002\185\n\190\n\198\002\185\000\000\000\000\000\000\000\000\002\185\000\000\002\185\000\000\002\185\002\185\000\000\000\000\000\000\000\000\002\185\002\185\002\185\000\000\000\000\000\000\000\000\000\000\000\000\002\185\002\185\n^\n\158\n\214\002\185\002\185\002\185\002\185\000\000\000\000\002\185\000\000\002\185\002\185\002\185\000\000\000\000\000\000\000\000\000\000\000\000\002\185\000\000\002\185\002\185\002\185\000\000\002\185\002\185\002\185\002\185\000\000\000\000\000\000\000\000\000\000\002\185\000\000\002\185\002\185\000\000\002\185\002\185\002\185\n\230\002\185\002\185\000\000\000\000\002\185\002\185\002\185\000\000\000\000\000\000\002Y\002\185\002\185\002\185\002\185\002Y\000\000\000\000\002Y\000\000\000\000\000\000\002Y\000\000\002Y\000\000\000\000\nV\000\000\002Y\002Y\002Y\000\000\002Y\002Y\002Y\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\002Y\000\000\002Y\000\000\000\000\000\000\000\000\000\000\002Y\002Y\n\190\n\198\002Y\000\000\000\000\000\000\000\000\002Y\000\000\002Y\000\000\002Y\002Y\000\000\000\000\000\000\000\000\002Y\002Y\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002Y\002Y\n^\n\158\n\214\n\222\002Y\002Y\002Y\000\000\000\000\002Y\000\000\002Y\002Y\002Y\000\000\000\000\000\000\000\000\000\000\000\000\002Y\000\000\002Y\002Y\002Y\000\000\002Y\002Y\002Y\002Y\000\000\000\000\000\000\000\000\000\000\002Y\000\000\002Y\002Y\000\000\002Y\002Y\002Y\n\230\002Y\002Y\000\000\000\000\002Y\002Y\002Y\000\000\000\000\000\000\002\145\002Y\002Y\002Y\002Y\002\145\000\000\000\000\002\145\000\000\000\000\000\000\002\145\000\000\002\145\000\000\000\000\nV\000\000\002\145\002\145\002\145\000\000\002\145\002\145\002\145\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\002\145\000\000\002\145\000\000\000\000\000\000\000\000\000\000\002\145\002\145\n\190\n\198\002\145\000\000\000\000\000\000\000\000\002\145\000\000\002\145\000\000\002\145\002\145\000\000\000\000\000\000\000\000\002\145\002\145\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\145\002\145\n^\n\158\n\214\n\222\002\145\002\145\002\145\000\000\000\000\002\145\000\000\002\145\002\145\002\145\000\000\000\000\000\000\000\000\000\000\000\000\002\145\000\000\002\145\002\145\002\145\000\000\002\145\002\145\002\145\002\145\000\000\000\000\000\000\000\000\000\000\002\145\000\000\002\145\002\145\000\000\002\145\002\145\002\145\n\230\002\145\002\145\000\000\000\000\002\145\002\145\002\145\000\000\000\000\000\000\002\137\002\145\002\145\002\145\002\145\002\137\000\000\000\000\002\137\000\000\000\000\000\000\002\137\000\000\002\137\000\000\000\000\nV\000\000\002\137\002\137\002\137\000\000\002\137\002\137\002\137\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\002\137\000\000\002\137\000\000\000\000\000\000\000\000\000\000\002\137\002\137\n\190\n\198\002\137\000\000\000\000\000\000\000\000\002\137\000\000\002\137\000\000\002\137\002\137\000\000\000\000\000\000\000\000\002\137\002\137\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\137\002\137\n^\n\158\n\214\n\222\002\137\002\137\002\137\000\000\000\000\002\137\000\000\002\137\002\137\002\137\000\000\000\000\000\000\000\000\000\000\000\000\002\137\000\000\002\137\002\137\002\137\000\000\002\137\002\137\002\137\002\137\000\000\000\000\000\000\000\000\000\000\002\137\000\000\002\137\002\137\000\000\002\137\002\137\002\137\n\230\002\137\002\137\000\000\000\000\002\137\002\137\002\137\000\000\000\000\000\000\002\153\002\137\002\137\002\137\002\137\002\153\000\000\000\000\002\153\000\000\000\000\000\000\002\153\000\000\002\153\000\000\000\000\nV\000\000\002\153\002\153\002\153\000\000\002\153\002\153\002\153\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\002\153\000\000\000\000\000\000\000\000\000\000\002\153\002\153\n\190\n\198\002\153\000\000\000\000\000\000\000\000\002\153\000\000\002\153\000\000\n\206\002\153\000\000\000\000\000\000\000\000\002\153\002\153\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\153\002\153\n^\n\158\n\214\n\222\n\238\002\153\002\153\000\000\000\000\002\153\000\000\002\153\002\153\n\246\000\000\000\000\000\000\000\000\000\000\000\000\002\153\000\000\002\153\002\153\n\254\000\000\002\153\002\153\002\153\002\153\000\000\000\000\000\000\000\000\000\000\002\153\000\000\002\153\002\153\000\000\002\153\002\153\002\153\n\230\002\153\002\153\000\000\000\000\002\153\011\006\002\153\000\000\000\000\000\000\002\157\002\153\002\153\011\014\011\022\002\157\000\000\000\000\002\157\000\000\000\000\000\000\002\157\000\000\002\157\000\000\000\000\nV\000\000\002\157\002\157\002\157\000\000\002\157\002\157\002\157\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\002\157\000\000\002\157\000\000\000\000\000\000\000\000\000\000\002\157\002\157\n\190\n\198\002\157\000\000\000\000\000\000\000\000\002\157\000\000\002\157\000\000\n\206\002\157\000\000\000\000\000\000\000\000\002\157\002\157\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\157\002\157\n^\n\158\n\214\n\222\n\238\002\157\002\157\000\000\000\000\002\157\000\000\002\157\002\157\n\246\000\000\000\000\000\000\000\000\000\000\000\000\002\157\000\000\002\157\002\157\n\254\000\000\002\157\002\157\002\157\002\157\000\000\000\000\000\000\000\000\000\000\002\157\000\000\002\157\002\157\000\000\002\157\002\157\002\157\n\230\002\157\002\157\000\000\000\000\002\157\002\157\002\157\000\000\000\000\000\000\002\161\002\157\002\157\011\014\011\022\002\161\000\000\000\000\002\161\000\000\000\000\000\000\002\161\000\000\002\161\000\000\000\000\nV\000\000\002\161\002\161\002\161\000\000\002\161\002\161\002\161\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\002\161\000\000\002\161\000\000\000\000\000\000\000\000\000\000\002\161\002\161\n\190\n\198\002\161\000\000\000\000\000\000\000\000\002\161\000\000\002\161\000\000\n\206\002\161\000\000\000\000\000\000\000\000\002\161\002\161\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\161\002\161\n^\n\158\n\214\n\222\n\238\002\161\002\161\000\000\000\000\002\161\000\000\002\161\002\161\n\246\000\000\000\000\000\000\000\000\000\000\000\000\002\161\000\000\002\161\002\161\n\254\000\000\002\161\002\161\002\161\002\161\000\000\000\000\000\000\000\000\000\000\002\161\000\000\002\161\002\161\000\000\002\161\002\161\002\161\n\230\002\161\002\161\000\000\000\000\002\161\002\161\002\161\000\000\000\000\000\000\b\225\002\161\002\161\011\014\011\022\b\225\000\000\000\000\b\225\000\000\000\000\000\000\b\225\000\000\b\225\000\000\000\000\nV\000\000\b\225\b\225\b\225\000\000\b\225\b\225\b\225\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\b\225\000\000\000\000\000\000\000\000\000\000\b\225\b\225\n\190\n\198\b\225\000\000\000\000\000\000\000\000\b\225\000\000\b\225\000\000\n\206\b\225\000\000\000\000\000\000\000\000\b\225\b\225\000\238\000\000\000\000\000\000\000\000\000\000\000\000\b\225\b\225\n^\n\158\n\214\n\222\n\238\b\225\b\225\000\000\000\000\b\225\000\000\b\225\b\225\n\246\000\000\000\000\000\000\000\000\000\000\000\000\b\225\000\000\b\225\b\225\n\254\000\000\b\225\b\225\b\225\b\225\000\000\000\000\000\000\000\000\000\000\b\225\000\000\b\225\b\225\000\000\b\225\b\225\b\225\n\230\b\225\b\225\000\000\000\000\b\225\011\006\b\225\000\000\000\000\000\000\002\165\b\225\b\225\011\014\011\022\002\165\000\000\000\000\002\165\000\000\000\000\000\000\002\165\000\000\002\165\000\000\000\000\nV\000\000\002\165\002\165\002\165\000\000\002\165\002\165\002\165\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\002\165\000\000\000\000\000\000\000\000\000\000\002\165\002\165\n\190\n\198\002\165\000\000\000\000\000\000\000\000\002\165\000\000\002\165\000\000\n\206\002\165\000\000\000\000\000\000\000\000\002\165\002\165\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\165\002\165\n^\n\158\n\214\n\222\n\238\002\165\002\165\000\000\000\000\002\165\000\000\002\165\002\165\n\246\000\000\000\000\000\000\000\000\000\000\000\000\002\165\000\000\002\165\002\165\n\254\000\000\002\165\002\165\002\165\002\165\000\000\000\000\000\000\000\000\000\000\002\165\000\000\002\165\002\165\000\000\011\030\002\165\011&\n\230\002\165\002\165\000\000\000\000\002\165\011\006\002\165\000\000\000\000\000\000\b\221\002\165\002\165\011\014\011\022\b\221\000\000\000\000\b\221\000\000\000\000\000\000\b\221\000\000\b\221\000\000\000\000\nV\000\000\b\221\b\221\b\221\000\000\b\221\b\221\b\221\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\b\221\000\000\000\000\000\000\000\000\000\000\b\221\b\221\n\190\n\198\b\221\000\000\000\000\000\000\000\000\b\221\000\000\b\221\000\000\n\206\b\221\000\000\000\000\000\000\000\000\b\221\b\221\000\238\000\000\000\000\000\000\000\000\000\000\000\000\b\221\b\221\n^\n\158\n\214\n\222\n\238\b\221\b\221\000\000\000\000\b\221\000\000\b\221\b\221\n\246\000\000\000\000\000\000\000\000\000\000\000\000\b\221\000\000\b\221\b\221\n\254\000\000\b\221\b\221\b\221\b\221\000\000\000\000\000\000\000\000\000\000\b\221\000\000\b\221\b\221\000\000\b\221\b\221\b\221\n\230\b\221\b\221\000\000\000\000\b\221\011\006\b\221\000\000\000\000\000\000\002\209\b\221\b\221\011\014\011\022\002\209\000\000\000\000\002\209\000\000\000\000\000\000\002\209\000\000\002\209\000\000\000\000\nV\000\000\002\209\002\209\002\209\000\000\002\209\002\209\002\209\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\002\209\000\000\000\000\000\000\000\000\000\000\002\209\002\209\n\190\n\198\002\209\000\000\000\000\000\000\000\000\002\209\000\000\002\209\000\000\n\206\002\209\000\000\000\000\000\000\000\000\002\209\002\209\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\209\002\209\n^\n\158\n\214\n\222\n\238\002\209\002\209\000\000\000\000\002\209\000\000\002\209\002\209\n\246\000\000\000\000\000\000\000\000\000\000\000\000\002\209\000\000\002\209\002\209\n\254\000\000\002\209\002\209\002\209\002\209\000\000\000\000\000\000\000\000\000\000\002\209\000\000\002\209\002\209\000\000\011\030\002\209\011&\n\230\002\209\002\209\000\000\000\000\002\209\011\006\002\209\000\000\000\000\000\000\002\225\002\209\002\209\011\014\011\022\002\225\000\000\000\000\002\225\000\000\000\000\000\000\002\225\000\000\002\225\000\000\000\000\nV\000\000\002\225\002\225\002\225\000\000\002\225\002\225\002\225\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\002\225\000\000\000\000\000\000\000\000\000\000\002\225\002\225\n\190\n\198\002\225\000\000\000\000\000\000\000\000\002\225\000\000\002\225\000\000\n\206\002\225\000\000\000\000\000\000\000\000\002\225\002\225\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\225\002\225\n^\n\158\n\214\n\222\n\238\002\225\002\225\000\000\000\000\002\225\000\000\002\225\002\225\n\246\000\000\000\000\000\000\000\000\000\000\000\000\002\225\000\000\002\225\002\225\n\254\000\000\002\225\002\225\002\225\002\225\000\000\000\000\000\000\000\000\000\000\002\225\000\000\002\225\002\225\000\000\011\030\002\225\011&\n\230\002\225\002\225\000\000\000\000\002\225\011\006\002\225\000\000\000\000\000\000\002\217\002\225\002\225\011\014\011\022\002\217\000\000\000\000\002\217\000\000\000\000\000\000\002\217\000\000\002\217\000\000\000\000\nV\000\000\002\217\002\217\002\217\000\000\002\217\002\217\002\217\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\002\217\000\000\000\000\000\000\000\000\000\000\002\217\002\217\n\190\n\198\002\217\000\000\000\000\000\000\000\000\002\217\000\000\002\217\000\000\n\206\002\217\000\000\000\000\000\000\000\000\002\217\002\217\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\217\002\217\n^\n\158\n\214\n\222\n\238\002\217\002\217\000\000\000\000\002\217\000\000\002\217\002\217\n\246\000\000\000\000\000\000\000\000\000\000\000\000\002\217\000\000\002\217\002\217\n\254\000\000\002\217\002\217\002\217\002\217\000\000\000\000\000\000\000\000\000\000\002\217\000\000\002\217\002\217\000\000\011\030\002\217\011&\n\230\002\217\002\217\000\000\000\000\002\217\011\006\002\217\000\000\000\000\000\000\002\197\002\217\002\217\011\014\011\022\002\197\000\000\000\000\002\197\000\000\000\000\000\000\002\197\000\000\002\197\000\000\000\000\nV\000\000\002\197\002\197\002\197\000\000\002\197\002\197\002\197\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\002\197\000\000\000\000\000\000\000\000\000\000\002\197\002\197\n\190\n\198\002\197\000\000\000\000\000\000\000\000\002\197\000\000\002\197\000\000\n\206\002\197\000\000\000\000\000\000\000\000\002\197\002\197\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\197\002\197\n^\n\158\n\214\n\222\n\238\002\197\002\197\000\000\000\000\002\197\000\000\002\197\002\197\n\246\000\000\000\000\000\000\000\000\000\000\000\000\002\197\000\000\002\197\002\197\n\254\000\000\002\197\002\197\002\197\002\197\000\000\000\000\000\000\000\000\000\000\002\197\000\000\002\197\002\197\000\000\011\030\002\197\011&\n\230\002\197\002\197\000\000\000\000\002\197\011\006\002\197\000\000\000\000\000\000\002\205\002\197\002\197\011\014\011\022\002\205\000\000\000\000\002\205\000\000\000\000\000\000\002\205\000\000\002\205\000\000\000\000\nV\000\000\002\205\002\205\002\205\000\000\002\205\002\205\002\205\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\002\205\000\000\000\000\000\000\000\000\000\000\002\205\002\205\n\190\n\198\002\205\000\000\000\000\000\000\000\000\002\205\000\000\002\205\000\000\n\206\002\205\000\000\000\000\000\000\000\000\002\205\002\205\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\205\002\205\n^\n\158\n\214\n\222\n\238\002\205\002\205\000\000\000\000\002\205\000\000\002\205\002\205\n\246\000\000\000\000\000\000\000\000\000\000\000\000\002\205\000\000\002\205\002\205\n\254\000\000\002\205\002\205\002\205\002\205\000\000\000\000\000\000\000\000\000\000\002\205\000\000\002\205\002\205\000\000\011\030\002\205\011&\n\230\002\205\002\205\000\000\000\000\002\205\011\006\002\205\000\000\000\000\000\000\002\201\002\205\002\205\011\014\011\022\002\201\000\000\000\000\002\201\000\000\000\000\000\000\002\201\000\000\002\201\000\000\000\000\nV\000\000\002\201\002\201\002\201\000\000\002\201\002\201\002\201\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\002\201\000\000\000\000\000\000\000\000\000\000\002\201\002\201\n\190\n\198\002\201\000\000\000\000\000\000\000\000\002\201\000\000\002\201\000\000\n\206\002\201\000\000\000\000\000\000\000\000\002\201\002\201\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\201\002\201\n^\n\158\n\214\n\222\n\238\002\201\002\201\000\000\000\000\002\201\000\000\002\201\002\201\n\246\000\000\000\000\000\000\000\000\000\000\000\000\002\201\000\000\002\201\002\201\n\254\000\000\002\201\002\201\002\201\002\201\000\000\000\000\000\000\000\000\000\000\002\201\000\000\002\201\002\201\000\000\011\030\002\201\011&\n\230\002\201\002\201\000\000\000\000\002\201\011\006\002\201\000\000\000\000\000\000\002\213\002\201\002\201\011\014\011\022\002\213\000\000\000\000\002\213\000\000\000\000\000\000\002\213\000\000\002\213\000\000\000\000\nV\000\000\002\213\002\213\002\213\000\000\002\213\002\213\002\213\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\002\213\000\000\000\000\000\000\000\000\000\000\002\213\002\213\n\190\n\198\002\213\000\000\000\000\000\000\000\000\002\213\000\000\002\213\000\000\n\206\002\213\000\000\000\000\000\000\000\000\002\213\002\213\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\213\002\213\n^\n\158\n\214\n\222\n\238\002\213\002\213\000\000\000\000\002\213\000\000\002\213\002\213\n\246\000\000\000\000\000\000\000\000\000\000\000\000\002\213\000\000\002\213\002\213\n\254\000\000\002\213\002\213\002\213\002\213\000\000\000\000\000\000\000\000\000\000\002\213\000\000\002\213\002\213\000\000\011\030\002\213\011&\n\230\002\213\002\213\000\000\000\000\002\213\011\006\002\213\000\000\000\000\000\000\002\229\002\213\002\213\011\014\011\022\002\229\000\000\000\000\002\229\000\000\000\000\000\000\002\229\000\000\002\229\000\000\000\000\nV\000\000\002\229\002\229\002\229\000\000\002\229\002\229\002\229\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\002\229\000\000\000\000\000\000\000\000\000\000\002\229\002\229\n\190\n\198\002\229\000\000\000\000\000\000\000\000\002\229\000\000\002\229\000\000\n\206\002\229\000\000\000\000\000\000\000\000\002\229\002\229\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\229\002\229\n^\n\158\n\214\n\222\n\238\002\229\002\229\000\000\000\000\002\229\000\000\002\229\002\229\n\246\000\000\000\000\000\000\000\000\000\000\000\000\002\229\000\000\002\229\002\229\n\254\000\000\002\229\002\229\002\229\002\229\000\000\000\000\000\000\000\000\000\000\002\229\000\000\002\229\002\229\000\000\011\030\002\229\011&\n\230\002\229\002\229\000\000\000\000\002\229\011\006\002\229\000\000\000\000\000\000\002\221\002\229\002\229\011\014\011\022\002\221\000\000\000\000\002\221\000\000\000\000\000\000\002\221\000\000\002\221\000\000\000\000\nV\000\000\002\221\002\221\002\221\000\000\002\221\002\221\002\221\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\002\221\000\000\000\000\000\000\000\000\000\000\002\221\002\221\n\190\n\198\002\221\000\000\000\000\000\000\000\000\002\221\000\000\002\221\000\000\n\206\002\221\000\000\000\000\000\000\000\000\002\221\002\221\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\221\002\221\n^\n\158\n\214\n\222\n\238\002\221\002\221\000\000\000\000\002\221\000\000\002\221\002\221\n\246\000\000\000\000\000\000\000\000\000\000\000\000\002\221\000\000\002\221\002\221\n\254\000\000\002\221\002\221\002\221\002\221\000\000\000\000\000\000\000\000\000\000\002\221\000\000\002\221\002\221\000\000\011\030\002\221\011&\n\230\002\221\002\221\000\000\000\000\002\221\011\006\002\221\000\000\000\000\000\000\002\193\002\221\002\221\011\014\011\022\002\193\000\000\000\000\002\193\000\000\000\000\000\000\002\193\000\000\002\193\000\000\000\000\nV\000\000\002\193\002\193\002\193\000\000\002\193\002\193\002\193\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\002\193\000\000\000\000\000\000\000\000\000\000\002\193\002\193\n\190\n\198\002\193\000\000\000\000\000\000\000\000\002\193\000\000\002\193\000\000\n\206\002\193\000\000\000\000\000\000\000\000\002\193\002\193\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\193\002\193\n^\n\158\n\214\n\222\n\238\002\193\002\193\000\000\000\000\002\193\000\000\002\193\002\193\n\246\000\000\000\000\000\000\000\000\000\000\000\000\002\193\000\000\002\193\002\193\n\254\000\000\002\193\002\193\002\193\002\193\000\000\000\000\000\000\000\000\000\000\002\193\000\000\002\193\002\193\000\000\011\030\002\193\011&\n\230\002\193\002\193\000\000\000\000\002\193\011\006\002\193\000\000\000\000\000\000\002\029\002\193\002\193\011\014\011\022\002\029\000\000\000\000\002\029\000\000\000\000\000\000\002\029\000\000\002\029\000\000\000\000\002\029\000\000\002\029\002\029\002\029\000\000\002\029\002\029\002\029\000\000\000\000\000\000\000\000\000\000\002\029\002\029\002\029\002\029\002\029\000\000\002\029\000\000\000\000\000\000\000\000\000\000\002\029\002\029\002\029\002\029\002\029\000\000\000\000\000\000\000\000\002\029\000\000\002\029\000\000\002\029\002\029\000\000\000\000\000\000\000\000\002\029\002\029\002\029\000\000\000\000\000\000\000\000\000\000\000\000\002\029\002\029\002\029\002\029\002\029\002\029\002\029\002\029\002\029\000\000\000\000\002\029\000\000\002\029\002\029\002\029\000\000\000\000\000\000\000\000\000\000\000\000\002\029\000\000\002\029\002\029\002\029\000\000\002\029\002\029\002\029\002\029\000\000\000\000\000\000\000\000\000\000\002\029\000\000\002\029\002\029\000\000\002\029\002\029\002\029\002\029\002\029\002\029\000\000\000\000\002\029\002\029\024\014\000\000\000\000\000\000\0025\002\029\002\029\002\029\002\029\0025\000\000\000\000\0025\000\000\000\000\000\000\0025\000\000\0025\000\000\000\000\nV\000\000\0025\0025\0025\000\000\0025\0025\0025\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\0025\000\000\000\000\000\000\000\000\000\000\0025\0025\n\190\n\198\0025\000\000\000\000\000\000\000\000\0025\000\000\0025\000\000\n\206\0025\000\000\000\000\000\000\000\000\0025\0025\000\238\000\000\000\000\000\000\000\000\000\000\000\000\0025\0025\n^\n\158\n\214\n\222\n\238\0025\0025\000\000\000\000\0025\000\000\0025\0025\n\246\000\000\000\000\000\000\000\000\000\000\000\000\0025\000\000\0025\0025\n\254\000\000\0025\0025\024&\0025\000\000\000\000\000\000\000\000\000\000\0025\000\000\0025\0025\000\000\011\030\0025\011&\n\230\0025\0025\000\000\000\000\0025\011\006\0025\000\000\000\000\000\000\0021\0025\0025\011\014\011\022\0021\000\000\000\000\0021\000\000\000\000\000\000\0021\000\000\0021\000\000\000\000\nV\000\000\0021\0021\0021\000\000\0021\0021\0021\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\0021\000\000\000\000\000\000\000\000\000\000\0021\0021\n\190\n\198\0021\000\000\000\000\000\000\000\000\0021\000\000\0021\000\000\n\206\0021\000\000\000\000\000\000\000\000\0021\0021\000\238\000\000\000\000\000\000\000\000\000\000\000\000\0021\0021\n^\n\158\n\214\n\222\n\238\0021\0021\000\000\000\000\0021\000\000\0021\0021\n\246\000\000\000\000\000\000\000\000\000\000\000\000\0021\000\000\0021\0021\n\254\000\000\0021\0021\0021\0021\000\000\000\000\000\000\000\000\000\000\0021\000\000\0021\0021\000\000\011\030\0021\011&\n\230\0021\0021\000\000\000\000\0021\011\006\0021\000\000\000\000\000\000\002\189\0021\0021\011\014\011\022\002\189\000\000\000\000\002\189\000\000\000\000\000\000\002\189\000\000\002\189\000\000\000\000\nV\000\000\002\189\002\189\002\189\000\000\002\189\002\189\002\189\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\002\189\000\000\000\000\000\000\000\000\000\000\002\189\002\189\n\190\n\198\002\189\000\000\000\000\000\000\000\000\002\189\000\000\002\189\000\000\n\206\002\189\000\000\000\000\000\000\000\000\002\189\002\189\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\189\002\189\n^\n\158\n\214\n\222\n\238\002\189\002\189\000\000\000\000\002\189\000\000\002\189\002\189\n\246\000\000\000\000\000\000\000\000\000\000\000\000\002\189\000\000\002\189\002\189\n\254\000\000\002\189\002\189\002\189\002\189\000\000\000\000\000\000\000\000\000\000\002\189\000\000\002\189\002\189\000\000\011\030\002\189\011&\n\230\002\189\002\189\000\000\000\000\002\189\011\006\002\189\000\000\000\000\000\000\002)\002\189\002\189\011\014\011\022\002)\000\000\000\000\002)\000\000\000\000\000\000\002)\000\000\002)\000\000\000\000\002)\000\000\002)\002)\002)\000\000\002)\002)\002)\000\000\000\000\000\000\000\000\000\000\002)\002)\002)\002)\002)\000\000\002)\000\000\000\000\000\000\000\000\000\000\002)\002)\002)\002)\002)\000\000\000\000\000\000\000\000\002)\000\000\002)\000\000\002)\002)\000\000\000\000\000\000\000\000\002)\002)\002)\000\000\000\000\000\000\000\000\000\000\000\000\002)\002)\002)\002)\002)\002)\002)\002)\002)\000\000\000\000\002)\000\000\002)\002)\002)\000\000\000\000\000\000\000\000\000\000\000\000\002)\000\000\002)\002)\002)\000\000\002)\002)\002)\002)\000\000\000\000\000\000\000\000\000\000\002)\000\000\002)\002)\000\000\002)\002)\002)\002)\002)\002)\000\000\000\000\002)\002)\024\014\000\000\000\000\000\000\001\233\002)\002)\002)\002)\001\233\000\000\000\000\001\233\000\000\000\000\000\000\001\233\000\000\001\233\000\000\000\000\001\233\000\000\001\233\001\233\001\233\000\000\001\233\001\233\001\233\000\000\000\000\000\000\000\000\000\000\001\233\001\233\001\233\001\233\001\233\000\000\001\233\000\000\000\000\000\000\000\000\000\000\001\233\001\233\001\233\001\233\001\233\000\000\000\000\000\000\000\000\001\233\000\000\001\233\000\000\001\233\001\233\000\000\000\000\000\000\000\000\001\233\001\233\001\233\000\000\000\000\000\000\000\000\000\000\000\000\001\233\001\233\001\233\001\233\001\233\001\233\001\233\001\233\001\233\000\000\000\000\001\233\000\000\001\233\001\233\001\233\000\000\000\000\000\000\000\000\000\000\000\000\001\233\000\000\001\233\001\233\001\233\000\000\001\233\001\233\001\233\001\233\000\000\000\000\000\000\000\000\000\000\001\233\000\000\001\233\001\233\000\000\001\233\001\233\001\233\001\233\001\233\001\233\000\000\000\000\001\233\001\233\024\014\000\000\000\000\000\000\002-\001\233\001\233\001\233\001\233\002-\000\000\000\000\002-\000\000\000\000\000\000\002-\000\000\002-\000\000\000\000\002-\000\000\002-\002-\002-\000\000\002-\002-\002-\000\000\000\000\000\000\000\000\000\000\002-\002-\002-\002-\002-\000\000\002-\000\000\000\000\000\000\000\000\000\000\002-\002-\002-\002-\002-\000\000\000\000\000\000\000\000\002-\000\000\002-\000\000\002-\002-\000\000\000\000\000\000\000\000\002-\002-\002-\000\000\000\000\000\000\000\000\000\000\000\000\002-\002-\002-\002-\002-\002-\002-\002-\002-\000\000\000\000\002-\000\000\002-\002-\002-\000\000\000\000\000\000\000\000\000\000\000\000\002-\000\000\002-\002-\002-\000\000\002-\002-\002-\002-\000\000\000\000\000\000\000\000\000\000\002-\000\000\002-\002-\000\000\002-\002-\002-\002-\002-\002-\000\000\000\000\002-\002-\024\014\000\000\000\000\000\000\0272\002-\002-\002-\002-\001\237\000\000\000\000\001\237\000\000\000\000\000\000\001\237\000\000\001\237\000\000\000\000\001\237\000\000\001\237\001\237\001\237\000\000\001\237\001\237\001\237\000\000\000\000\000\000\000\000\000\000\001\237\001\237\001\237\001\237\001\237\000\000\001\237\000\000\000\000\000\000\000\000\000\000\001\237\001\237\001\237\001\237\001\237\000\000\000\000\000\000\000\000\001\237\000\000\001\237\000\000\001\237\001\237\000\000\000\000\000\000\000\000\001\237\001\237\001\237\000\000\000\000\000\000\000\000\000\000\000\000\001\237\001\237\001\237\001\237\001\237\001\237\001\237\001\237\001\237\000\000\000\000\001\237\000\000\001\237\001\237\001\237\000\000\000\000\000\000\000\000\000\000\000\000\027B\000\000\001\237\001\237\001\237\000\000\001\237\001\237\001\237\001\237\000\000\000\000\000\000\000\000\000\000\001\237\000\000\001\237\001\237\000\000\001\237\001\237\001\237\001\237\001\237\001\237\000\000\000\000\001\237\001\237\001\237\000\000\000\000\000\000\001\241\001\237\001\237\001\237\001\237\001\241\000\000\000\000\001\241\000\000\000\000\000\000\001\241\000\000\001\241\000\000\000\000\001\241\000\000\001\241\001\241\001\241\000\000\001\241\001\241\001\241\000\000\000\000\000\000\000\000\000\000\001\241\001\241\001\241\001\241\001\241\000\000\001\241\000\000\000\000\000\000\000\000\000\000\001\241\001\241\001\241\001\241\001\241\000\000\000\000\000\000\000\000\001\241\000\000\001\241\000\000\001\241\001\241\000\000\000\000\000\000\000\000\001\241\001\241\001\241\000\000\000\000\000\000\000\000\000\000\000\000\001\241\001\241\001\241\001\241\001\241\001\241\001\241\001\241\001\241\000\000\000\000\001\241\000\000\001\241\001\241\001\241\000\000\000\000\000\000\000\000\000\000\000\000\027:\000\000\001\241\001\241\001\241\000\000\001\241\001\241\001\241\001\241\000\000\000\000\000\000\000\000\000\000\001\241\000\000\001\241\001\241\000\000\001\241\001\241\001\241\001\241\001\241\001\241\000\000\000\000\001\241\001\241\024\014\000\000\000\000\000\000\000\000\001\241\001\241\001\241\001\241\000\006\000\246\000\000\000\000\007\005\001\002\001\006\000\000\001\n\001\022\001\"\000\000\000\000\000\000\000\000\001&\001b\000\000\000\000\000\000\001f\000\000\000\000\000\000\007\005\001*\000\000\000\000\000\000\003\210\001n\tV\tZ\001z\001~\000\000\000\000\000\000\0012\000\000\003z\000\000\025B\000\000\tz\t~\007\005\003\182\003\194\003\206\003\218\003\226\t\130\007:\000\000\001\206\007\005\003F\000\000\000\000\003\214\007\005\007\005\000\238\b\142\b\146\b\158\b\174\000\000\005n\007\005\007\005\001\210\001\214\001\218\001\222\001\226\000\000\000\000\b\198\001\230\000\000\000\000\000\000\000\000\001\234\000\000\b\210\b\234\t\n\t\030\005z\000\000\005~\000\000\000\000\001\238\000\000\000\000\007\005\000\000\000\000\b\166\001\242\b\170\000\000\000\000\000\000\000\000\000\000\007\005\000\000\000\000\000\000\002.\006\"\000\000\000\000\005\130\b\186\000\000\0022\000\000\022\234\004j\t\150\020F\002:\000\000\002>\002B\000\006\000\246\000\000\000\000\001\189\001\002\001\006\000\000\001\n\001\022\001\"\000\000\000\000\000\000\000\000\001&\001b\000\000\000\000\000\000\tR\000\000\000\000\000\000\001\189\001*\000\000\000\000\000\000\003\210\001n\tV\tZ\001z\001~\000\000\000\000\b\230\0012\000\000\003z\000\000\t^\000\000\tz\t~\001\189\003\182\003\194\003\206\003\218\003\226\t\130\007:\007)\001\206\001\189\003F\007)\000\000\003\214\001\189\001\189\000\238\b\142\b\146\b\158\b\174\000\000\005n\001\189\001\189\001\210\001\214\001\218\001\222\001\226\000\000\023\250\b\198\001\230\000\000\000\000\000\000\000\000\001\234\000\000\b\210\b\234\t\n\t\030\005z\000\000\005~\000\000\000\000\001\238\000\000\000\238\001\189\000\000\000\000\b\166\001\242\b\170\000\000\002\237\002\237\011\174\000\000\001\189\000\000\000\000\000\000\002.\006^\000\000\000\000\005\130\b\186\000\000\0022\002\237\022\234\004j\t\150\000\000\002:\000\000\002>\002B\000\006\000\246\000\000\000\n\001\174\001\002\001\006\002\182\001\n\001\022\001\"\000\000\000\000\000\000\000\000\001&\0062\000\000\003N\005\222\000\000\000\000\004\149\000\000\003R\001*\006F\011\154\000\000\001.\006N\003V\003Z\002\237\002\237\002\237\003^\000\000\0012\000\000\003z\000\000\011\170\002\237\003\174\003\178\000\000\003\182\003\194\003\206\003\218\003\226\006\234\007:\002\237\000\000\0126\003F\000\000\000\000\003\214\012>\000\n\000\000\b\142\b\146\b\158\b\174\000\000\005n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012F\002\237\b\198\002\237\002\237\014\190\000\000\000\000\000\000\002\237\b\210\b\234\t\n\t\030\005z\002\237\005~\012Z\012\158\002\237\000\000\004\149\004\149\000\000\000\000\b\166\000\000\b\170\000\000\000\000\000\000\000\n\000\000\000\000\000\000\000\000\000\000\000\000\002\237\r~\018\002\005\130\b\186\0252\000\000\000\000\t2\004j\t\150\000\006\000\246\000\000\000\000\001\174\001\002\001\006\002\182\001\n\001\022\001\"\000\000\002\237\000\000\000\000\001&\000\000\000\000\004\181\000\000\b\249\000\000\b\249\b\249\003R\001*\003b\001\006\000\000\001.\000\000\003V\003Z\000\000\000\000\000\000\003^\000\000\0012\000\000\003z\000\000\011\170\000\000\003\174\003\178\001*\003\182\003\194\003\206\003\218\003\226\006\234\007:\000\000\000\000\0126\003F\000\000\018\030\003\214\012>\002Z\002^\b\142\b\146\b\158\b\174\000\000\005n\019r\003\134\000\000\000\000\019v\000\000\000\000\012F\003F\b\198\000\000\028\134\001*\002\134\002r\019\166\000\000\b\210\b\234\t\n\t\030\005z\002~\005~\012Z\012\158\000\000\000\000\028\167\024.\000\000\000\000\b\166\000\000\b\170\000\000\002\130\003.\000\000\019\182\000\000\000\000\003:\000\000\003F\004\026\004&\018\002\005\130\b\186\b\249\0042\000\000\t2\004j\t\150\000\006\000\246\000\000\000\000\001\174\001\002\001\006\002\182\001\n\001\022\001\"\000\000\0046\000\000\000\000\001&\002\237\000\000\028\214\000\000\002\237\000\000\003\254\000\000\003R\001*\000\000\000\000\000\000\001.\000\000\003V\003Z\000\000\000\000\000\000\003^\000\000\0012\000\000\003z\000\000\011\170\000\n\003\174\003\178\000\000\003\182\003\194\003\206\003\218\003\226\006\234\007:\000\000\004j\0126\003F\000\000\002\237\003\214\012>\002Z\002^\b\142\b\146\b\158\b\174\000\000\005n\000\000\000\000\000\000\002\237\002\237\000\000\000\000\012F\000\000\b\198\000\000\028\134\001*\002\134\002r\000\000\000\000\b\210\b\234\t\n\t\030\005z\002~\005~\012Z\012\158\000\000\000\000\004\189\002\142\000\000\000\000\b\166\002\237\b\170\000\000\002\130\003.\000\000\000\000\000\000\000\000\003:\000\000\003F\004\026\004&\018\002\005\130\b\186\022\250\0042\000\000\t2\004j\t\150\000\181\001\002\001\006\000\181\012}\000\000\001\"\000\000\t\190\000\000\000\000\001&\0046\000\000\000\181\000\000\000\181\000\000\000\181\000\000\000\181\001*\000\000\t\238\005a\001.\000\000\000\000\005a\000\000\000\000\t\246\000\181\000\000\0012\000\000\003z\000\000\000\181\000\000\000\000\000\000\000\181\000\000\000\000\003\206\002N\000\181\012I\000\181\000\000\000\000\000\181\003F\000\000\000\000\003\214\000\181\000\181\000\181\b\142\b\146\b\158\000\000\019\214\005n\000\181\000\181\000\000\012I\000\000\000\000\002\194\000\181\000\000\002\198\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012}\012}\005z\002\210\005~\000\181\000\181\002\218\0125\000\181\000\181\000\000\000\000\b\166\000\000\b\170\005a\000\000\000\000\000\000\000\000\000\181\000\000\012}\000\000\000\000\012}\000\181\000\181\005\130\b\186\000\000\002\222\005a\t2\004j\005a\000\181\000\000\000\181\000\205\001\002\001\006\000\205\000\000\000\000\001\"\000\000\t\190\000\000\000\000\001&\000\000\000\000\000\205\000\000\000\205\000\000\000\205\000\000\000\205\001*\000\000\t\238\000\000\001.\000\000\000\000\000\000\000\000\000\000\t\246\000\205\000\000\0012\000\000\003z\000\000\000\205\000\000\000\000\002\226\000\205\000\000\000\000\003\206\002N\000\205\000\000\000\205\000\000\002\237\000\205\003F\000\000\000\000\003\214\000\205\000\205\000\205\b\142\b\146\b\158\000\000\019\214\005n\000\205\000\205\011\162\000\000\000\000\002\237\000\000\000\205\000\000\000\000\000\000\000\205\000\000\000\000\000\n\000\000\000\000\000\000\000\000\000\000\000\000\005z\007\245\005~\000\205\000\205\000\000\002\237\000\205\000\205\002\237\000\000\b\166\000\000\b\170\000\000\000\000\002\237\000\000\000\000\000\205\000\000\002\237\000\000\002\237\000\000\000\205\000\205\005\130\b\186\000\000\002\237\002\237\t2\004j\000\000\000\205\000\014\000\205\000\018\000\022\000\026\000\030\000\238\000\"\000&\000\000\000*\000.\0002\000\000\0006\000:\000\000\000\000\000>\000\000\000\000\000\000\000B\002\237\000\000\000\000\000\000\000\000\000\000\000F\000\000\000\000\000\000\000\000\002\237\000J\000\000\000N\000R\000V\000Z\000^\000b\000f\000\000\000\000\000\000\000j\000\000\000n\000\000\000r\000\000\000\000\000v\0062\000\000\000\000\005\222\000\000\000\000\000\000\002Z\002^\000\000\006F\000\000\000\000\000z\006N\000\000\000~\000\130\000\000\000\000\000\000\000\000\001f\000\134\000\138\000\142\000\000\001*\002\134\002r\000\000\000\000\000\146\000\150\000\154\000\000\000\158\002~\000\000\000\162\000\166\000\170\000\000\000\000\002\142\000\174\000\178\000\182\000\000\000\000\000\000\002\130\003.\000\186\000\000\000\190\000\194\003:\000\000\003F\004\026\004&\000\000\000\198\000\000\000\202\0042\003\241\001B\001\006\003\241\000\206\000\210\001\"\000\214\006\186\012\137\000\000\001&\000\000\000\000\003\241\000\000\0046\000\000\003\241\000\000\003\241\001*\000\000\006\218\000\000\000\000\000\000\000\000\001F\012\137\000\000\006\242\003\241\000\000\000\000\000\000\000\000\000\000\003\241\000\000\000\000\001R\000\000\000\000\000\000\007\030\002N\003\241\000\000\003\241\012\178\012\137\003\241\003F\000\000\000\000\003\246\003\241\003\241\na\003\250\012\137\004\002\000\000\007.\005n\012\137\012\137\000\238\000\000\000\000\000\000\000\000\003\241\003\241\012\137\012\137\005r\000\000\002\237\002\237\000\000\000\000\000\000\000\000\000\000\000\000\005z\002\237\005~\003\241\003\241\0076\000\000\003\241\003\241\000\000\000\000\000\000\002\237\000\000\000\000\000\000\000\000\012\137\000\000\000\000\000\n\na\t\202\000\000\na\024\230\003\241\005\130\012\137\000\000\000\000\na\000\000\004j\000\000\na\002\237\003\241\001B\001\006\005\254\000\000\000\000\001\"\002\237\000\000\000\000\000\000\001&\001b\002\237\000\000\000\000\001f\000\000\000\000\000\000\000\000\001*\000\000\002\237\000\000\001j\001n\001r\001v\001z\001~\000\000\000\000\000\000\002\237\000\000\002\237\000\000\001\130\000\000\001\194\006\030\002\237\000\000\000\000\001^\002N\000\000\001\202\000\000\000\n\001\206\000\000\003F\000\000\001\021\003\246\000\000\000\000\002\237\003\250\000\000\004\002\005b\000\000\005n\002\237\002\237\001\210\001\214\001\218\001\222\001\226\007B\002\237\001\021\001\230\005r\000\000\000\000\002\237\001\234\000\000\000\000\000\000\000\000\000\000\005z\000\000\005~\000\000\005\190\001\238\000\000\000\000\000\000\000\000\001\021\000\000\001\242\001>\000\000\000\000\002\237\000\000\000\000\000\000\001\021\000\000\000\000\002.\006\"\001\021\006\130\005\130\000\000\t\r\0022\000\000\0026\004j\001\021\001\021\002:\000\000\002>\002B\001B\001\006\007\"\000\000\000\000\001\"\000\000\000\000\000\000\000\000\001&\001b\000\000\000\000\000\000\001f\000\000\000\000\000\000\000\000\001*\000\000\001\162\001\021\001j\001n\001r\001v\001z\001~\000\238\000\000\000\000\001\166\001\021\000\000\000\000\001\130\000\000\001\194\006\030\001*\000\000\000\000\001^\002N\000\000\001\202\000\000\000\000\001\206\000\000\003F\000\000\004\129\003\246\000\000\000\000\002\154\003\250\000\000\004\002\005b\000\000\005n\007f\002j\001\210\001\214\001\218\001\222\001\226\000\000\003F\004\129\001\230\005r\000\000\000\000\0062\001\234\000\000\005\222\000\000\000\000\000\000\005z\t\r\005~\006F\005\190\001\238\000\000\006N\000\000\000\000\004\129\000\000\001\242\000\000\000\000\000\000\007j\000\000\000\000\000\000\004\129\000\000\000\000\002.\006\"\004\129\011\146\005\130\000\000\015\186\0022\000\000\0026\004j\004\129\004\129\002:\012}\002>\002B\001B\001\006\b\250\000\000\000\000\001\"\000\000\000\000\000\000\003R\001&\001b\000\000\000\000\000\000\001f\000\000\005e\000\000\000\000\001*\005e\000\000\004\129\001j\001n\001r\001v\001z\001~\000\000\015\230\000\000\000\000\004\129\000\000\000\000\001\130\000\000\001\194\006\030\0126\000\000\000\000\001^\002N\012>\001\202\000\000\000\000\001\206\000\000\003F\000\000\000\000\003\246\016\018\000\000\000\000\003\250\000\000\004\002\005b\000\000\005n\000\000\000\000\001\210\001\214\001\218\001\222\001\226\000\000\000\000\000\000\001\230\005r\000\000\012}\012}\001\234\000\000\000\000\000\000\004\165\000\000\005z\000\000\005~\000\000\005\190\001\238\000\000\000\000\005e\016v\000\000\000\000\001\242\000\000\000\000\012}\000\000\000\000\012}\000\000\000\000\000\000\000\000\002.\006\"\005e\000\000\005\130\005e\000\000\0022\000\000\0026\004j\000\000\000\000\002:\000\000\002>\002B\001B\001\006\023\186\000\000\000\000\001\"\000\000\000\000\000\000\000\000\001&\001b\000\000\000\000\000\000\001f\000\000\000\000\000\000\000\000\001*\000\000\000\000\000\000\001j\001n\001r\001v\001z\001~\000\000\000\000\003r\002\170\001\006\000\000\000\000\001\130\000\000\001\194\006\030\000\000\002\174\000\000\001^\002N\000\000\001\202\b^\000\000\001\206\000\000\003F\001*\000\000\003\246\000\000\000\000\000\000\003\250\000\000\004\002\005b\000\000\005n\000\000\000\000\001\210\001\214\001\218\001\222\001\226\000\000\000\000\000\000\001\230\005r\003n\000\000\000\000\001\234\000\000\000\000\000\000\000\000\003F\005z\000\000\005~\000\000\005\190\001\238\000\000\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\000\000\000\002\237\002\237\000\000\000\000\000\000\000\000\000\000\002.\006\"\000\000\000\000\005\130\007N\000\000\0022\000\000\0026\004j\000\000\000\000\002:\002\237\002>\002B\002\237\002\237\000\000\002\237\000\n\002\237\002\237\002\237\002\237\002\237\002\237\000\000\000\000\000\000\000\000\002\237\002\237\000\000\000\000\000\000\002\237\002\237\002\237\000\000\000\000\002\237\000\000\002\237\000\n\002\237\002\237\002\237\002\237\000\n\002\237\000\000\007>\000\000\002\237\000\000\002\237\000\000\024\142\000\000\002\237\002\237\000\000\002\237\002\237\002\237\002\237\002\237\002\237\002\237\000\000\002\237\000\000\002\237\002\237\002\237\002\237\002\237\002\237\002\237\002\237\002\237\002\237\002\237\000\000\002\237\000\000\000\000\000\000\000\000\000\000\000\000\002\237\000\000\000\000\002\237\000\000\002\237\000\000\000\000\000\000\000\000\002\237\002\237\002\237\002\237\002\237\002\237\000\000\002\237\002\237\024\170\000\000\000\000\000\000\002\237\000\000\000\000\002\237\000\000\002\237\000\000\000A\000A\000\000\000\000\004\129\000A\000A\002\237\000A\000A\000A\002\237\002\237\002\237\000\000\000A\000\000\002\237\002\237\002\237\006\181\000\000\000\000\000\000\004\129\000A\000\000\000\000\000\000\000A\000\000\000A\000A\000\000\000\000\000\000\000\000\000\000\000A\000\000\000A\000\000\000\000\000\000\000A\000A\004\129\000A\000A\000A\000A\000A\000A\000A\000\000\000\000\004\129\000A\000\000\000\000\000A\004\129\011\146\000\238\000A\000A\000A\000A\000\000\000A\000\000\004\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000A\000A\000A\000A\000A\000\000\000A\000\000\000\000\000\000\000\000\000\000\004\129\000\000\000\000\000A\000\000\000A\000\000\000=\000=\000\000\000\000\004\129\000=\000=\000\000\000=\000=\000=\000\000\000A\000A\000\000\000=\000\000\000A\000A\000A\006\177\000\000\000\000\000\000\000\000\000=\000\000\000\000\000\000\000=\000\000\000=\000=\000\000\000\000\000\000\000\000\000\000\000=\000\000\000=\000\000\000\000\000\000\000=\000=\000\000\000=\000=\000=\000=\000=\000=\000=\000\000\000\000\000\000\000=\000\000\000\000\000=\000\000\000\000\000\000\000=\000=\000=\000=\000\000\000=\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000=\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000=\000=\000=\000=\000=\000\000\000=\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000=\000\000\000=\000\000\011\217\011\217\000\000\000\000\018*\011\217\011\217\000\000\011\217\011\217\011\217\000\000\000=\000=\000\000\011\217\000\000\000=\000=\000=\006\193\000\000\000\000\000\000\003R\011\217\000\000\000\000\000\000\011\217\000\000\011\217\011\217\000\000\000\000\000\000\000\000\000\000\011\217\000\000\011\217\000\000\000\000\000\000\011\217\011\217\018\154\011\217\011\217\011\217\011\217\011\217\011\217\011\217\000\000\000\000\0126\011\217\000\000\000\000\011\217\012>\000\000\000\000\011\217\011\217\011\217\011\217\000\000\011\217\019V\019f\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\217\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\217\011\217\011\217\011\217\011\217\000\000\011\217\000\000\000\000\000\000\000\000\000\000\004\173\000\000\000\000\011\217\000\000\011\217\000\000\011\213\011\213\000\000\000\000\020f\011\213\011\213\000\000\011\213\011\213\011\213\000\000\011\217\011\217\000\000\011\213\000\000\011\217\011\217\011\217\006\189\000\000\000\000\000\000\000\000\011\213\000\000\000\000\000\000\011\213\000\000\011\213\011\213\000\000\000\000\000\000\000\000\000\000\011\213\000\000\011\213\000\000\000\000\000\000\011\213\011\213\000\000\011\213\011\213\011\213\011\213\011\213\011\213\011\213\000\000\000\000\000\000\011\213\000\000\000\000\011\213\000\000\000\000\000\000\011\213\011\213\011\213\011\213\000\000\011\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\213\011\213\011\213\011\213\011\213\000\000\011\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\213\000\000\011\213\000\006\000\246\000\000\000\000\000\000\001\002\001\006\000\000\001\n\001\022\001\"\000\000\000\000\011\213\011\213\001&\000\000\000\000\011\213\011\213\011\213\000\000\023\n\000\000\000\000\001*\000\000\000\000\000\000\001.\000\000\003V\003Z\000\000\000\000\000\000\000\000\000\000\0012\000\000\003z\000\000\000\000\000\000\003\174\003\178\000\000\003\182\003\194\003\206\003\218\003\226\006\234\007:\000\000\000\000\000\000\003F\000\000\000\000\003\214\000\000\000\000\000\000\b\142\b\146\b\158\b\174\000\000\005n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\198\000\000\000\000\000\000\0051\000\000\0051\0051\b\210\b\234\t\n\t\030\005z\0051\005~\000\000\0051\000\000\0051\000\000\0051\0051\0051\b\166\0051\b\170\000\000\000\000\012I\0125\0051\000\000\0051\0051\0051\000\000\0051\0051\0051\005\130\b\186\000\000\0051\0051\t2\004j\t\150\000\000\000\000\012I\0051\000\000\002\194\000\000\000\000\002\198\0051\0051\000\000\000\000\0051\0051\0051\0051\0051\0051\000\000\0051\002\210\000\000\0051\000\000\002\218\0125\000\000\0051\0051\0051\000\000\000\000\000\000\0051\000\000\000\000\0051\0051\000\000\000\000\000\000\000\000\000\000\0051\000\000\000\000\0051\0051\0051\002\222\0051\0051\004a\000\000\000\000\004a\000\000\000\000\000\000\000\000\0051\0051\0051\000\000\0051\0051\004a\000\000\016\250\0051\004a\000\000\004a\000\000\000\000\000\000\0051\000\000\0051\0051\0051\000\000\0032\0051\004a\000\000\000\000\000\000\0051\000\000\004a\000\000\0051\n}\0051\0051\n}\n}\002\226\000\000\000\000\n}\000\000\n}\004a\000\000\n}\000\000\000\000\004a\n}\n}\000\000\n}\n}\000\000\n}\000\000\n}\000\000\000\000\000\000\000\000\n}\000\000\004a\n}\000\000\000\000\000\000\000\000\000\000\007\153\000\000\n}\000\000\n}\000\000\000\000\000\000\n}\n}\004a\004a\000\000\000\000\004a\004a\n}\007\153\007\153\n}\007\153\007\153\n}\n}\000\000\n}\000\000\n}\n}\000\000\000\000\000\000\000\000\004a\000\000\000\000\000\000\n}\000\000\000\000\n}\007\153\000\000\000\000\015\006\000\000\000\000\000\000\000\000\000\000\n}\000\000\n}\000\000\000\000\n}\000\000\n}\000\000\000\000\000\000\007\153\000\000\000\000\005\158\000\000\000\000\000\000\000\000\000\000\000\000\n}\n}\000\000\n}\n}\007\153\n}\000\000\n}\000\000\n}\b\229\n}\000\000\n}\000\000\b\229\000\000\002^\b\229\000\000\000\000\000\000\007\153\001\029\007\153\000\000\000\000\b\229\000\000\b\229\b\229\b\229\000\000\b\229\b\229\b\229\000\000\000\000\005\214\000\000\000\000\007\153\007\153\001\029\000\000\000\000\007\153\b\229\007\153\006\245\006\245\000\000\007\153\b\229\b\229\000\000\000\000\b\229\000\000\000\000\000\000\0036\b\229\000\000\b\229\001\029\004*\b\229\015\170\006\245\006\245\006\245\b\229\b\229\b\229\001\029\000\000\000\000\000\000\006\245\001\029\b\229\b\229\000\000\000\000\000\000\000\000\000\000\b\229\000\000\001\029\000\000\004\146\006\245\006\245\000\000\b\229\000\000\000\000\006\245\000\000\006\245\006\245\006\245\000\000\b\229\b\229\b\229\006\245\b\229\b\229\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\029\000\000\000\000\b\229\000\000\b\229\b\229\006\245\000\000\012\017\b\229\001\029\000\000\000\000\012\017\b\229\002^\012\017\000\000\b\229\000\000\b\229\b\229\000\000\000\000\000\000\004\178\000\000\012\017\012\017\012\017\000\000\012\017\012\017\012\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\017\000\000\004\030\000\000\006\245\000\000\012\017\012\017\000\000\000\000\012\017\000\000\000\000\000\000\0036\012\017\001\174\012\017\000\000\r\130\012\017\000\000\000\000\000\000\000\000\012\017\012\017\012\017\000\000\000\000\014\142\000\000\000\000\000\000\012\017\012\017\003R\000\000\000\000\000\000\000\000\012\017\000\000\000\000\000\000\004\146\000\000\000\000\014\146\012\017\000\000\000\000\000\000\000\000\014\186\000\000\000\000\000\000\012\017\012\017\012\017\000\000\012\017\012\017\000\000\000\000\000\000\000\000\0126\000\000\000\000\000\000\000\000\012>\012\017\000\000\012\017\012\017\000\000\000\000\b\233\012\017\000\000\000\000\000\000\b\233\012\017\002^\b\233\015N\012\017\000\000\012\017\012\017\000\000\000\000\000\000\b\233\000\000\b\233\b\233\b\233\000\000\b\233\b\233\b\233\012Z\015b\000\000\000\000\004\137\004\137\000\000\000\000\000\000\000\000\000\000\b\233\000\000\002Z\002^\018\178\000\000\b\233\b\233\000\000\000\000\b\233\000\000\015r\000\000\0036\b\233\000\000\b\233\000\000\000\000\b\233\000\000\001*\002b\002r\b\233\b\233\b\233\000\000\000\000\000\000\000\000\002~\000\000\b\233\b\233\000\000\000\000\000\000\000\000\000\000\b\233\000\000\000\000\000\000\004\146\002\130\003.\000\000\b\233\000\000\000\000\003:\000\000\003F\004\026\004&\000\000\b\233\b\233\b\233\0042\b\233\b\233\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\233\000\000\b\233\b\233\0046\000\000\000\000\b\233\000a\000\000\000a\000a\b\233\000\000\000\000\000\000\b\233\000\000\b\233\b\233\000a\000\000\000a\000a\000\000\000\000\000a\000a\000a\000\000\b\145\000\000\001B\001\006\000\000\000\000\000\000\001\"\000\000\000\000\000a\000\000\001&\000\000\000\000\000\000\000a\000a\000\000\t\017\000a\000\000\001*\000\000\000a\000a\000\000\000a\000\000\001F\000a\000\000\000\000\000\000\000\000\000a\000a\000a\000\000\000\000\000\000\000\000\001R\000\000\000a\000a\001^\002N\000\000\000\000\000\000\000a\000a\000\000\003F\000a\000\000\003\246\000\000\000a\000\000\003\250\000\000\004\002\005b\000\000\005n\000\000\000a\000a\000a\000\000\000a\000a\000\000\000\000\000\000\000\000\005r\000\000\b\145\000\000\000\000\000\000\000a\000\000\000\000\000a\005z\012\021\005~\000a\005\190\000\000\012\021\000\000\000a\012\021\000\000\000\000\000a\000\000\000a\000\000\000\000\000\000\004\130\000\000\012\021\012\021\012\021\000\000\012\021\012\021\012\021\005\130\000\000\t\017\000\000\b\222\000\000\004j\000\000\000\000\000\000\000\000\012\021\000\000\002Z\002^\019.\000\000\012\021\012\021\000\000\000\000\012\021\000\000\000\000\000\000\000\000\012\021\000\000\012\021\000\000\000\000\012\021\000\000\001*\002b\002r\012\021\012\021\012\021\000\000\000\000\000\000\000\000\002~\000\000\012\021\012\021\000\000\000\000\000\000\000\000\000\000\012\021\000\000\000\000\000\000\012\021\002\130\003.\000\000\012\021\000\000\000\000\003:\000\000\003F\004\026\004&\000\000\012\021\012\021\012\021\0042\012\021\012\021\003)\000\000\000\000\000\000\000\000\003)\012I\0125\003)\000\000\012\021\000\000\012\021\012\021\0046\002Z\002^\012\021\000\000\003)\003)\003)\012\021\003)\003)\003)\012\021\012I\012\021\012\021\002\194\000\000\000\000\002\198\000\000\001*\002\134\003)\000\000\000\000\002\206\000\000\000\000\003)\004z\000\000\002\210\003)\000\000\000\000\002\218\0125\003)\000\000\003)\000\000\000\000\003)\000\000\002\130\0036\000\000\003)\003)\003)\003:\000\000\003F\004\026\004&\000\000\003)\003)\000\000\0042\002\222\012\198\000\000\003)\000\000\000\000\000\000\003)\000\000\000\000\n\137\003)\000\000\001B\001\006\000\000\0046\000\000\001\"\000\000\003)\003)\003)\001&\003)\003)\000\000\n\137\n\137\000\000\n\137\n\137\000\000\001*\000\000\000\000\003)\000\000\003)\003)\001F\000\000\000\000\003)\000\000\000\000\000\000\000\000\003)\002\226\000\000\n\137\003)\001R\003)\003)\000\000\001^\002N\000\000\000\000\000\000\000\000\000\000\000\000\003F\000\000\000\000\003\246\000\000\000\000\n\137\003\250\000\000\004\002\005b\000\000\005n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\137\000\000\000\000\005r\000\000\000\000\n\133\000\000\000\000\001B\001\006\000\000\000\000\005z\001\"\005~\000\000\005\190\n\137\001&\n\137\000\000\000\000\n\133\n\133\000\000\n\133\n\133\000\000\001*\000\000\000\000\000\000\000\000\n\137\000\000\001F\n\137\n\137\000\000\005\130\000\000\n\137\000\000\n\137\000\000\004j\n\133\n\137\001R\000\000\000\000\000\000\005\250\002N\000\000\000\000\000\000\000\000\000\000\000\000\003F\000\000\000\000\003\246\000\000\000\000\n\133\003\250\000\000\004\002\005b\000\000\005n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\133\000\000\000\000\005r\000\000\000\000\001\213\000\000\000\000\000\000\000\000\001\213\000\000\005z\001\213\005~\000\000\005\190\n\133\000\000\n\133\000\000\000\000\000\000\000\000\001\213\001\213\001\213\000\000\001\213\001\213\001\213\000\000\000\000\n\133\000\000\000\000\n\133\n\133\000\000\005\130\000\000\n\133\001\213\n\133\000\000\004j\000\000\n\133\001\213\001\213\000\000\000\000\001\213\000\000\000\000\000\000\000\000\001\213\000\000\001\213\000\000\000\000\001\213\000\000\000\000\000\000\000\000\001\213\001\213\001\213\000\000\000\000\000\000\000\000\000\000\000\000\001\213\001\213\000\000\001i\000\000\000\000\001i\001\213\000\000\000\000\000\000\001\213\000\000\000\000\000\000\001\213\000\000\001i\000\000\001i\000\000\001i\000\000\001i\001\213\001\213\001\213\000\000\001\213\001\213\000\000\000\000\000\000\000\000\000\000\001i\000\000\000\000\000\000\000\000\001\213\001i\001\213\001\213\001B\001\006\000\000\001\213\000\000\001\"\000\000\006\186\001\213\000\000\001&\001i\004\246\000\000\001\213\000\000\001i\001i\000\238\000\000\001*\000\000\006\218\000\000\000\000\000\000\000\000\001F\000\000\000\000\006\242\000\000\001i\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001R\000\000\000\000\000\000\007\030\002N\000\000\000\000\000\000\001i\001i\001i\003F\001i\001i\003\246\000\000\000\000\na\003\250\000\000\004\002\000\000\007.\005n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001i\004-\000\000\000\000\005r\000\000\000\000\000\000\000\000\000\000\000\000\001i\000\000\000\000\005z\000\000\005~\000\000\000\000\0076\000\000\005\169\000\000\000\000\000\000\000\000\005\169\000\000\000\000\005\169\000\000\000\000\000\000\000\000\000\000\na\000\000\000\000\na\na\005\169\005\130\005\169\000\000\005\169\na\005\169\004j\000\000\na\004-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\169\000\000\000\000\000\000\000\000\000\000\005\169\005\169\000\000\000\000\000\000\000\000\000\000\005\169\000\000\005\169\000\000\005\169\000\000\000\000\005\169\000\000\000\000\000\000\000\000\005\169\005\169\005\169\000\000\000\000\000\000\000\000\003u\000\000\000\000\000\000\000\000\003u\000\000\000\000\003u\005\169\005\169\000\000\000\000\005\169\000\000\000\000\000\000\000\000\000\000\003u\000\000\003u\000\000\003u\000\000\003u\005\169\005\169\005\169\000\000\005\169\005\169\000\000\000\000\003u\000\000\000\000\003u\b\026\003u\000\000\000\000\003u\003u\003u\005\169\000\000\000\000\005\169\005\169\0059\000\000\003u\003u\003u\003u\000\000\003u\000\000\003u\005\169\000\000\003u\003u\003u\000\000\000\000\000\000\000\000\000\000\000\000\003u\000\000\000\000\000\000\000\000\000\000\003u\003u\000\000\000\000\000\000\003u\000\000\005=\000\000\003u\000\000\003u\000\000\000\000\003u\000\000\000\000\000\000\003u\003u\003u\003u\003u\003u\000\000\000\000\005\157\000\000\000\000\000\000\0059\005\157\000\000\000\000\005\157\003u\000\000\003u\003u\003u\000\000\003u\000\000\000\000\000\000\005\157\000\000\005\157\000\000\005\157\000\000\005\157\003u\003u\003u\000\000\003u\003u\000\000\000\000\000\000\000\000\000\000\005\157\005=\000\000\000\000\000\000\000\000\005\157\005\157\003u\003u\000\000\000\000\003u\bZ\000\000\005\157\000\000\005\157\000\000\000\000\005\157\000\000\000\000\003u\000\000\005\157\005\157\000\238\000\000\000\000\000\000\bq\000\000\000\000\000\000\000\000\bq\000\000\000\000\bq\000\000\005\157\005\157\000\000\000\000\005\157\000\000\000\000\000\000\000\000\bq\000\000\bq\000\000\bq\000\000\bq\000\000\005\157\005\157\005\157\000\000\005\157\005\157\000\000\000\000\000\000\000\000\bq\000\000\000\000\000\000\000\000\000\000\bq\bq\000\000\005\157\000\000\000\000\005\157\005\157\000\000\bq\000\000\bq\000\000\000\000\bq\000\000\000\000\000\000\005\157\bq\bq\bq\000\000\000\000\000\000\000\000\012\201\000\000\000\000\000\000\000\000\012\201\000\000\000\000\012\201\bq\000\000\000\000\000\000\bq\000\000\000\000\000\000\000\000\000\000\012\201\000\000\012\201\000\000\012\201\000\000\012\201\bq\bq\bq\000\000\bq\bq\000\000\000\000\000\000\000\000\000\000\012\201\000\000\000\000\000\000\000\000\bq\012\201\012\201\bq\000\000\000\000\000\000\bq\004>\000\000\012\201\000\000\012\201\000\000\000\000\012\201\004\246\000\000\bq\000\000\012\201\012\201\012\201\000\000\000\000\000\000\000\000\012\205\000\000\000\000\000\000\000\000\012\205\000\000\000\000\012\205\012\201\000\000\000\000\000\000\012\201\000\000\000\000\000\000\000\000\000\000\012\205\000\000\012\205\000\000\012\205\000\000\012\205\012\201\012\201\012\201\000\000\012\201\012\201\000\000\000\000\000\000\000\000\000\000\012\205\004J\000\000\000\000\000\000\000\000\012\205\012\205\012\201\000\000\000\000\000\000\012\201\004>\000\000\012\205\000\000\012\205\000\000\000\000\012\205\000\000\000\000\012\201\000\000\012\205\012\205\012\205\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\197\000\000\002^\001\197\000\000\012\205\000\000\000\000\000\000\012\205\000\000\000\000\b\209\000\000\001\197\000\000\000\000\000\000\001\197\000\000\001\197\000\000\012\205\012\205\012\205\000\000\012\205\012\205\000\000\000\000\000\000\000\000\001\197\000\000\004J\000\000\000\000\000\000\001\197\001\197\000\000\012\205\000\000\000\000\000\000\012\205\0036\001\197\000\000\001\197\000\000\000\000\001\197\000\000\000\000\000\000\012\205\001\197\001\197\001\197\000\000\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\197\001\197\000\000\000\000\004\146\000\000\000\000\000\000\000\000\000\000\000\000\003Y\000\000\002^\003Y\000\000\000\000\001\197\001\197\000\000\000\000\001\197\001\197\b\205\000\000\003Y\000\000\000\000\000\000\003Y\000\000\003Y\000\000\001\197\000\000\000\000\000\000\000\000\000\000\000\000\001\197\000\000\000\000\003Y\000\000\001\197\000\000\000\000\000\000\003Y\001\193\001\197\000\000\000\000\000\000\000\000\000\000\0036\003Y\000\000\003Y\000\000\000\000\003Y\000\000\000\000\000\000\000\000\003Y\003Y\003Y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003Y\003Y\000\000\000\000\004\146\000\000\000\000\000\000\000\000\000\000\000\000\003U\000\000\002^\003U\000\000\000\000\003Y\003Y\000\000\000\000\003Y\003Y\b\205\000\000\003U\000\000\000\000\000\000\003U\000\000\003U\000\000\003Y\000\000\000\000\000\000\000\000\000\000\000\000\003Y\000\000\000\000\003U\000\000\003Y\000\000\000\000\000\000\003U\001\193\003Y\000\000\000\000\000\000\000\000\000\000\0036\003U\000\000\003U\000\189\000\000\003U\000\189\000\000\000\000\000\000\003U\003U\003U\000\000\000\000\000\000\000\000\000\189\000\000\000\189\000\000\000\189\000\000\000\189\000\000\000\000\003U\003U\000\000\000\000\004\146\000\000\000\000\000\000\000\000\000\189\000\000\000\000\000\000\000\000\000\000\000\189\000\000\003U\003U\000\189\000\000\003U\003U\000\000\000\189\000\000\000\189\000\000\000\000\000\189\000\000\000\000\000\000\003U\000\189\000\189\000\238\000\000\000\000\000\000\003U\000\000\000\000\000\189\000\189\003U\001\001\000\000\000\000\001\001\000\189\003U\000\000\000\000\000\189\000\000\000\000\000\000\000\000\000\000\001\001\000\000\001\001\000\000\001\001\000\000\001\001\000\189\000\189\000\000\000\000\000\189\000\189\000\000\000\000\000\000\000\000\000\000\001\001\000\000\000\000\000\000\000\000\000\189\001\001\000\000\000\000\000\000\001\001\000\189\000\189\000\000\000\000\001\001\000\000\001\001\000\000\000\000\001\001\000\189\000\000\000\189\000\000\001\001\001\001\000\238\000\000\000\000\000\000\000\000\000\000\000\000\001\001\001\001\000\000\000\197\000\000\000\000\000\197\001\001\000\000\000\000\000\000\001\001\000\000\000\000\000\000\000\000\000\000\000\197\000\000\000\197\000\000\000\197\000\000\000\197\001\001\001\001\000\000\000\000\001\001\001\001\000\000\000\000\000\000\000\000\000\000\000\197\000\000\000\000\000\000\000\000\001\001\000\197\000\000\000\000\000\000\000\197\001\001\001\001\000\000\000\000\000\197\000\000\000\197\000\000\000\000\000\197\001\001\000\000\001\001\000\000\000\197\000\197\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\197\000\197\000\000\000\193\000\000\000\000\000\193\000\197\000\000\000\000\000\000\000\197\000\000\000\000\000\000\000\000\000\000\000\193\000\000\000\193\000\000\000\193\000\000\000\193\000\197\000\197\000\000\000\000\000\197\000\197\000\000\000\000\000\000\000\000\000\000\000\193\000\000\000\000\000\000\000\000\000\197\000\193\000\000\000\000\000\000\000\193\000\197\000\197\000\000\000\000\000\193\000\000\000\193\000\000\000\000\000\193\000\197\000\000\000\197\000\000\000\193\000\193\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\193\000\193\000\000\000\000\000\000\000\000\000\000\000\193\000\000\000\000\000\000\000\193\000\000\000\000\000\000\000\000\nV\000\000\000\000\021\166\b\245\000\000\b\245\b\245\000\193\000\193\000\000\000\000\000\193\000\193\n\142\n\166\n\174\n\150\n\182\000\000\000\000\000\000\000\000\000\000\000\193\000\000\000\000\000\000\n\190\n\198\000\193\000\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\206\000\193\000\000\000\193\000\000\000\000\000\000\000\000\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n^\n\158\n\214\n\222\n\238\001b\000\000\000\000\000\000\001f\000\000\000\000\024B\n\246\000\000\000\000\000\000\000\000\001j\001n\001r\001\190\001z\001~\n\254\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\194\001\198\000\000\000\000\000\000\000\000\000\000\011\030\001\202\011&\n\230\001\206\000\000\000\000\000\000\b\245\011\006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\014\011\022\000\000\000\000\001\210\001\214\001\218\001\222\001\226\000\000\000\000\001\161\001\230\000\000\001\161\000\000\000\000\001\234\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\161\000\000\000\000\001\238\001\161\000\000\001\161\000\000\000\000\000\000\001\242\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\161\001\161\000\000\002.\027\154\000\000\001\161\000\000\012I\0125\0022\000\000\0026\0059\000\000\001\161\002:\001\161\002>\002B\001\161\000\000\000\000\000\000\000\000\001\161\001\161\001\161\000\000\012I\000\000\000\000\002\194\000\000\000\000\002\198\000\000\000\000\000\000\000\000\000\000\001\161\r\142\000\000\000\000\001\161\012\197\000\000\002\210\000\000\000\000\012\197\002\218\0125\012\197\000\000\000\000\000\000\001\161\001\161\000\000\000\000\001\161\001\161\000\000\012\197\000\000\012\197\000\000\012\197\0059\012\197\000\000\000\000\001\161\000\000\000\000\002\222\000\000\000\000\001\161\001\161\000\000\012\197\000\000\000\000\001\161\000\000\000\000\012\197\012\197\000\000\001\161\000\000\000\000\000\000\000\000\000\000\012\197\000\000\012\197\000\000\000\000\012\197\000\000\000\000\000\000\000\000\012\197\012\197\012\197\000\000\000\000\000\000\012\193\000\000\000\000\000\000\000\000\012\193\000\000\000\000\012\193\000\000\012\197\000\000\002\226\000\000\012\197\000\000\000\000\000\000\000\000\012\193\000\000\012\193\000\000\012\193\000\000\012\193\000\000\012\197\012\197\012\197\000\000\012\197\012\197\000\000\000\000\000\000\000\000\012\193\000\000\000\000\000\000\000\000\000\000\012\193\012\193\000\000\012\197\000\000\000\000\000\000\012\197\000\000\012\193\000\000\012\193\000\000\000\000\012\193\000\000\004\246\000\000\012\197\012\193\012\193\012\193\000\000\000\000\000\000\000\000\bu\000\000\000\000\000\000\000\000\bu\000\000\000\000\bu\012\193\000\000\000\000\000\000\012\193\000\000\000\000\000\000\000\000\000\000\bu\000\000\bu\000\000\bu\000\000\bu\012\193\012\193\012\193\000\000\012\193\012\193\000\000\000\000\000\000\000\000\000\000\bu\000\000\000\000\000\000\000\000\007\182\bu\bu\012\193\000\000\000\000\000\000\012\193\000\000\000\000\bu\000\000\bu\000\000\000\000\bu\000\000\000\000\012\193\000\000\bu\bu\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\193\000\000\002^\001\193\bu\000\000\000\000\000\000\bu\000\000\012%\000\000\b\205\012%\001\193\000\000\000\000\000\000\001\193\000\000\001\193\bu\bu\bu\012%\bu\bu\000\000\012%\000\000\012%\000\000\001\193\000\000\000\000\000\000\0051\bu\001\193\000\000\bu\000\000\012%\000\000\bu\000\000\0036\001\193\012%\001\193\000\000\000\000\001\193\000\000\000\000\bu\000\000\001\193\001\193\001\193\000\000\000\000\012%\000\000\000\000\000\000\000\000\012%\012%\000\000\000\000\000\000\000\000\001\193\001\193\000\000\000\000\004\146\000\000\000\000\000\000\000\000\000\000\012%\000\000\000\000\000\000\000\000\000\000\000\000\001\193\001\193\000\000\000\000\001\193\001\193\000\000\000\000\000\000\000\000\012%\012%\003\030\000\000\012%\012%\001\193\001\174\002Z\002^\r\130\000\000\000\000\001\193\000\000\000\000\012%\000\000\001\193\000\000\r\154\014\142\000\000\012%\001\193\004\137\000\000\003R\001*\002\134\002r\000\000\000\000\000\000\012%\000\000\000\000\000\000\002~\014\146\000\000\000\000\000\000\000\000\000\000\014\186\000\000\000\000\000\000\005\209\000\000\000\000\002\130\003.\005\209\000\000\000\000\005\209\003:\0126\003F\004\026\004&\000\000\012>\000\000\000\000\0042\005\209\000\000\005\209\000\000\005\209\000\000\005\209\000\000\000\000\000\000\000\000\000\000\015N\000\000\000\000\000\000\0046\000\000\005\209\000\000\000\000\000\000\000\000\000\000\005\209\005\209\000\000\000\000\000\000\012Z\015b\bZ\000\000\005\209\000\000\005\209\000\000\000\000\005\209\000\000\000\000\000\000\000\000\005\209\005\209\000\238\000\000\000\000\000\000\000\000\000\000\000\000\015r\000\000\000\000\001b\000\000\000\000\000\000\005\209\000\000\000\000\000\000\005\209\000\000\000\000\000\000\000\000\001j\001n\001r\001\190\001z\001~\000\000\000\000\005\209\005\209\005\209\000\000\005\209\005\209\000\000\001\194\001\198\000\000\000\000\000\000\000\000\000\000\000\000\001\202\000\000\000\000\001\206\005\209\000\000\000\000\000\000\005\209\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\209\001\210\001\214\001\218\001\222\001\226\000\000\000\000\000\000\001\230\000\000\000\000\000\000\000\000\001\234\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\238\000\000\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\000\001B\001\006\000\000\000\000\000\000\001\"\000\000\006\186\002.\027\182\001&\000\000\000\000\000\000\000\000\0022\000\000\0026\000\000\000\000\001*\002:\006\218\002>\002B\000\000\000\000\001F\000\000\000\000\006\242\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001R\000\000\000\000\000\000\007\030\002N\000\000\000\000\000\000\000\000\000\000\000\000\003F\000\000\000\000\003\246\000\000\000\000\000\000\003\250\007\138\004\002\000\000\007.\005n\005\205\000\000\000\000\005\205\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005r\000\000\000\000\005\205\000\000\005\205\000\000\005\205\000\000\005\205\005z\000\000\005~\000\000\000\000\0076\000\000\000\000\000\000\000\000\000\000\005\205\000\000\000\000\000\000\000\000\000\000\005\205\b\006\000\000\000\000\000\000\t\202\000\000\000\000\t\210\005\205\005\130\005\205\000\000\000\000\005\205\000\000\004j\000\000\000\000\005\205\005\205\000\238\000\000\000\000\000\000\012\209\000\000\000\000\000\000\000\000\012\209\000\000\000\000\012\209\000\000\005\205\000\000\000\000\000\000\005\205\000\000\000\000\000\000\000\000\012\209\000\000\012\209\000\000\012\209\000\000\012\209\000\000\005\205\005\205\005\205\000\000\005\205\005\205\000\000\000\000\000\000\000\000\012\209\000\000\000\000\000\000\000\000\000\000\012\209\012\209\000\000\005\205\000\000\000\000\000\000\005\205\000\000\012\209\000\000\012\209\000\000\000\000\012\209\000\000\000\000\000\000\005\205\012\209\012\209\000\238\000\000\000\000\000\000\012\213\000\000\000\000\000\000\000\000\012\213\000\000\000\000\012\213\000\000\012\209\000\000\000\000\000\000\012\209\000\000\000\000\000\000\000\000\012\213\000\000\012\213\000\000\012\213\000\000\012\213\000\000\012\209\012\209\012\209\000\000\012\209\012\209\000\000\000\000\000\000\000\000\012\213\000\000\000\000\000\000\000\000\000\000\012\213\b\006\000\000\012\209\000\000\000\000\000\000\012\209\000\000\012\213\000\000\012\213\000\000\000\000\012\213\000\000\000\000\000\000\012\209\012\213\012\213\000\238\000\000\000\000\000\000\007\138\000\000\000\000\000\000\000\000\005\225\000\000\000\000\005\225\000\000\012\213\000\000\000\000\000\000\012\213\000\000\000\000\000\000\000\000\005\225\000\000\005\225\000\000\005\225\000\000\005\225\000\000\012\213\012\213\012\213\000\000\012\213\012\213\000\000\000\000\000\000\000\000\005\225\000\000\000\000\000\000\000\000\000\000\005\225\b\006\000\000\012\213\000\000\000\000\000\000\012\213\000\000\005\225\000\000\005\225\000\000\000\000\005\225\000\000\000\000\000\000\012\213\005\225\005\225\000\238\000\000\000\000\000\000\005\229\000\000\000\000\000\000\000\000\005\229\000\000\000\000\005\229\000\000\005\225\000\000\000\000\000\000\005\225\000\000\000\000\000\000\000\000\005\229\000\000\005\229\000\000\005\229\000\000\005\229\000\000\005\225\005\225\005\225\000\000\005\225\005\225\000\000\000\000\000\000\000\000\005\229\000\000\000\000\000\000\000\000\000\000\005\229\005\229\000\000\005\225\000\000\000\000\000\000\005\225\000\000\005\229\000\000\005\229\000\000\000\000\005\229\000\000\000\000\000\000\005\225\005\229\005\229\005\229\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003Q\000\000\002^\003Q\000\000\005\229\000\000\000\000\000\000\005\229\000\000\000\000\000\000\000\000\003Q\000\000\002Z\002^\003Q\000\000\003Q\000\000\005\229\005\229\005\229\000\000\005\229\005\229\000\000\000\000\000\000\000\000\003Q\000\000\000\000\000\000\001*\002\134\003Q\000\000\000\000\005\229\000\000\000\000\000\000\005\229\0036\003Q\000\000\003Q\000\000\000\000\003Q\000\000\000\000\000\000\b.\003Q\003Q\003Q\002\130\003>\000\000\000\000\000\000\000\000\003:\000\000\003F\004\026\004&\000\000\000\000\003Q\003Q\0042\000\000\004\146\000\000\003M\000\000\002^\003M\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003Q\003Q\0046\003M\003Q\003Q\026\n\003M\000\000\003M\000\000\000\000\000\000\000\000\000\000\000\000\003Q\000\000\000\000\000\000\000\000\003M\000\000\003Q\000\000\000\000\025\246\003M\003Q\000\000\000\000\000\000\000\000\000\000\003Q\0036\003M\000\000\003M\000\000\000\000\003M\000\000\000\000\000\000\000\000\003M\003M\003M\000\000\000\000\000\000\000\000\000\000\001\205\000\000\012\170\001\205\000\000\000\000\001\"\000\000\003M\003M\000\000\000\000\004\146\000\000\001\205\000\000\000\000\000\000\001\205\000\000\001\205\000\000\002Z\002^\000\000\003M\003M\000\000\000\000\003M\003M\000\000\001\205\000\000\000\000\000\000\000\000\000\000\001\205\000\000\000\000\003M\001*\002\134\000\000\012\174\000\000\001\205\003M\001\205\000\000\000\000\001\205\003M\000\000\000\000\000\000\001\205\001\205\003M\012\186\000\000\000\000\000\000\000\000\000\000\002\130\003>\000\000\000\000\000\000\000\000\003:\001\205\003F\004\026\004&\001\205\000\000\000\000\000\000\0042\000\000\001Q\000\000\000\000\001Q\000\000\000\000\005~\001\205\001\205\000\000\000\000\001\205\001\205\000\000\001Q\0046\001Q\000\000\001Q\005\001\001Q\000\000\000\000\001\205\000\000\000\000\000\000\000\000\000\000\000\000\001\205\000\000\001Q\000\000\000\000\000\000\000\000\000\000\001Q\025\246\000\000\001\205\001Q\000\000\000\000\000\000\000\000\001Q\000\000\001Q\000\000\000\000\001Q\000\000\000\000\000\000\000\000\001Q\001Q\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001Q\000\000\001M\000\000\000\000\001M\001Q\000\000\000\000\000\000\001Q\000\000\000\000\000\000\000\000\000\000\001M\000\000\001M\000\000\001M\000\000\001M\001Q\001Q\001Q\000\000\001Q\001Q\000\000\000\000\000\000\000\000\000\000\001M\000\000\000\000\000\000\000\000\001Q\001M\000\000\000\000\000\000\001M\000\000\001Q\000\000\000\000\001M\000\000\001M\000\000\000\000\001M\000\000\000\000\001Q\000\000\001M\001M\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001M\000\000\nV\000\000\000\000\007\025\001M\000\000\000\000\007\025\001M\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\000\000\000\000\001M\001M\001M\000\000\001M\001M\000\000\n\190\n\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001M\000\000\n\206\000\000\000\000\000\000\000\000\001M\000\000\000\000\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001M\n^\n\158\n\214\n\222\n\238\nV\000\000\000\000\000\000\025\142\000\000\007\025\000\000\n\246\000\000\000\000\000\000\000\000\000\000\n\142\n\166\n\174\n\150\n\182\n\254\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\190\n\198\000\000\001\002\001\006\000\000\000\000\011\030\001\"\011&\n\230\n\206\000\000\001&\000\000\000\000\011\006\000\000\006q\000\238\000\000\000\000\000\000\001*\011\014\011\022\000\000\001.\n^\n\158\n\214\n\222\n\238\000\000\000\000\000\000\0012\000\000\003z\000\000\000\000\n\246\000\000\000\000\000\000\000\000\000\000\003\206\002N\000\000\000\000\000\000\n\254\000\000\000\000\003F\000\000\000\000\003\214\000\000\000\000\000\000\b\142\b\146\b\158\000\000\000\000\005n\011\030\025\146\011&\n\230\025\158\000\000\001B\001\006\000\000\011\006\000\000\001\"\000\000\006\186\000\000\000\000\001&\011\014\011\022\000\000\000\000\005z\000\000\005~\000\000\000\000\001*\000\000\006\218\000\000\000\000\000\000\b\166\001F\b\170\000\000\006\242\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\006\000\000\001R\000\000\005\130\b\186\023\182\002N\007\138\t2\004j\000\000\000\000\004\129\003F\000\000\004\129\003\246\000\000\000\000\000\000\003\250\000\000\004\002\000\000\007.\005n\004\129\000\000\000\000\000\000\004\129\000\000\004\129\000\000\000\000\000\000\000\000\005r\000\000\000\000\000\000\000\000\000\000\000\000\004\129\000\000\000\000\005z\000\000\005~\004\129\b\006\000\000\000\000\004\129\000\000\000\000\bZ\000\000\004\129\000\000\004\129\000\000\000\000\004\129\000\000\000\000\000\000\000\000\004\129\011\146\000\238\023\198\000\000\005\130\000\000\000\000\000\000\004\129\004\129\004j\b\001\000\000\000\000\b\001\004\129\004\129\000\000\000\000\004\129\000\000\000\000\000\000\000\000\000\000\b\001\000\000\000\000\000\000\b\001\000\000\b\001\004\129\004\129\000\000\000\000\004\129\004\129\000\000\000\000\000\000\000\000\000\000\b\001\b\026\000\000\000\000\000\000\004\129\b\001\000\000\000\000\000\000\b\001\000\000\004\129\000\000\000\000\b\001\000\000\b\001\000\000\007\253\b\001\000\000\007\253\004\129\000\000\b\001\b\001\000\238\000\000\000\000\000\000\000\000\000\000\007\253\b\001\b\001\000\000\007\253\000\000\007\253\000\000\b\001\000\000\000\000\000\000\b\001\000\000\000\000\000\000\000\000\000\000\007\253\000\000\000\000\000\000\000\000\000\000\007\253\b\001\b\001\b\001\007\253\b\001\b\001\000\000\000\000\007\253\000\000\007\253\003E\000\000\007\253\003E\000\000\b\001\000\000\007\253\007\253\000\238\000\000\000\000\b\001\000\000\003E\000\000\007\253\007\253\003E\000\000\003E\000\000\000\000\007\253\000\000\000\000\000\000\007\253\000\000\000\000\000\000\000\000\003E\012\194\000\000\000\000\000\000\000\000\003E\000\000\007\253\007\253\007\253\000\000\007\253\007\253\000\000\003E\000\000\003E\000\000\000\000\003E\000\000\000\000\000\000\007\253\003E\003E\003E\000\000\000\000\000\000\007\253\001}\000\000\012-\001}\000\000\000\000\000\000\000\000\000\000\003E\000\000\000\000\012-\003E\001}\000\000\001}\000\000\001}\000\000\001}\000\000\000\000\000\000\000\000\000\000\003E\003E\026~\000\000\003E\003E\001}\000\000\000\000\000\000\000\000\000\000\001}\012-\000\000\000\000\003E\000\000\000\000\000\000\012-\000\000\rB\003E\000\000\000\000\001}\000\000\003E\000\000\000\000\001}\001}\001}\003E\000\000\000\000\000\000\001A\000\000\000\165\001A\000\000\000\000\000\000\000\000\000\000\001}\000\000\000\000\000\165\012-\001A\000\000\001A\000\000\001A\000\000\001A\000\000\000\000\000\000\000\000\000\000\001}\001}\001}\000\000\001}\001}\001A\000\000\000\000\000\000\000\000\000\000\001A\000\165\000\000\000\000\000\000\000\000\000\000\000\000\000\165\000\000\000\000\001}\000\000\000\000\001A\000\000\000\000\000\000\000\000\001A\001A\001A\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\001A\000\000\000\000\000\000\000\165\001B\001\006\000\000\000\000\000\000\001\"\000\000\006\186\000\000\000\000\001&\000\000\001A\001A\001A\006u\001A\001A\000\000\000\000\001*\000\000\006\218\000\000\000\000\000\000\000\000\001F\000\000\000\000\006\242\000\000\000\000\000\000\000\000\001A\000\000\000\000\019\194\000\000\001R\000\000\000\000\000\000\001^\002N\001A\000\000\000\000\000\000\000\000\000\000\003F\000\000\000\000\003\246\000\000\000\000\000\000\003\250\000\000\004\002\005b\007.\005n\001B\001\006\000\000\000\000\000\000\001\"\000\000\006\186\000\000\000\000\001&\005r\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001*\005z\006\218\005~\000\000\005\190\018\026\001F\000\000\000\000\006\242\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001R\000\000\000\000\000\000\007\030\002N\020\150\000\000\005\130\000\000\006\170\000\000\003F\000\000\004j\003\246\000\000\000\000\000\000\003\250\000\000\004\002\000\000\007.\005n\001B\001\006\000\000\000\000\000\000\001\"\000\000\006\186\000\000\000\000\001&\005r\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001*\005z\006\218\005~\000\000\000\000\0076\001F\000\000\000\000\006\242\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001R\000\000\000\000\000\000\007\030\002N\018\174\000\000\005\130\000\000\000\000\000\000\003F\000\000\004j\003\246\000\000\001\002\001\006\003\250\000\000\004\002\001\"\007.\005n\000\000\000\000\001&\000\000\000\000\000\000\000\000\006\153\000\000\000\000\000\000\005r\001*\000\000\000\000\000\000\001.\000\000\000\000\000\000\000\000\005z\000\000\005~\000\000\0012\0076\003z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\206\002N\000\000\000\000\000\000\000\000\000\000\000\000\003F\000\000\019*\003\214\005\130\000\000\000\000\b\142\b\146\b\158\004j\000\000\005n\004i\004i\000\000\000\000\000\000\004i\000\000\000\000\000\000\000\000\004i\000\000\000\000\000\000\000\000\000\000\004i\000\000\000\000\000\000\004i\005z\000\000\005~\000\000\000\000\000\000\004i\019z\000\000\000\000\019\146\b\166\000\000\b\170\000\000\000\000\000\000\000\000\000\000\004i\000\000\000\000\000\000\004i\004i\000\000\000\000\005\130\b\186\000\000\000\000\004i\t2\004j\004i\000\000\003E\000\238\004i\003E\004i\004i\000\000\004i\000\000\000\000\000\000\000\000\000\000\000\000\003E\000\000\000\000\000\000\003E\004i\003E\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004i\000\000\004i\003E\012\194\000\000\000\000\000\000\000\000\003E\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003E\000\000\003E\012%\000\000\003E\012%\000\000\000\000\004i\003E\003E\003E\000\000\000\000\004i\000\000\012%\000\000\000\000\000\000\012%\000\000\012%\000\000\000\000\003E\000\000\000\000\0051\003E\000\000\000\000\000\000\000\000\012%\000\000\000\000\000\000\000\000\000\000\012%\000\000\003E\003E\026\174\000\000\003E\003E\000\000\012%\000\000\012%\000\000\000\000\012%\000\000\000\000\000\000\000\000\012%\012%\001B\001\006\000\000\rB\003E\001\"\000\000\000\000\000\000\003E\001&\000\000\000\000\000\000\012%\005\186\000\000\003\254\012%\000\000\001*\000\000\000\000\000\000\000\000\000\000\000\000\001F\000\000\000\000\000\000\012%\012%\003\030\000\000\012%\012%\000\000\000\000\000\000\001R\000\000\000\000\000\000\001^\002N\000\000\012%\000\000\000\000\000\000\014^\003F\000\000\012%\003\246\000\000\000\000\000\000\003\250\000\000\004\002\005b\000\000\005n\012%\000\000\000\000\000\000\000\000\000\000\000\000\001B\001\006\000\000\000\000\005r\001\"\000\000\006\186\000\000\000\000\001&\000\000\000\000\000\000\005z\000\000\005~\000\000\005\190\000\000\001*\000\000\006\218\000\000\000\000\000\000\000\000\001F\000\000\000\000\006\242\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006^\000\000\001R\005\130\000\000\000\000\b\246\002N\000\000\004j\000\000\000\000\000\000\005\133\003F\000\000\005\133\003\246\000\000\000\000\000\000\003\250\000\000\004\002\000\000\007.\005n\005\133\000\000\000\000\000\000\005\133\000\000\005\133\000\000\000\000\000\000\000\000\005r\000\000\000\000\000\000\000\000\000\000\000\000\005\133\000\000\000\000\005z\000\000\005~\005\133\000\000\000\000\000\000\000\000\000\000\000\000\bZ\000\000\005\133\000\000\005\133\000\000\000\000\005\133\000\000\000\000\000\000\000\000\005\133\005\133\000\238\000\000\000\000\005\130\000\000\000\000\000\000\000\000\000\000\004j\005\137\000\000\000\000\005\137\005\133\005\133\000\000\000\000\005\133\000\000\000\000\000\000\000\000\000\000\005\137\000\000\000\000\000\000\005\137\000\000\005\137\005\133\005\133\000\000\000\000\005\133\005\133\000\000\000\000\000\000\000\000\000\000\005\137\000\000\000\000\000\000\000\000\000\000\005\137\000\000\000\000\000\000\000\000\000\000\005\133\bZ\000\000\005\137\000\000\005\137\003E\000\000\005\137\003E\000\000\005\133\000\000\005\137\005\137\000\238\000\000\000\000\000\000\000\000\003E\000\000\000\000\000\000\003E\000\000\003E\000\000\000\000\005\137\005\137\000\000\000\000\005\137\000\000\000\000\000\000\000\000\003E\012\194\000\000\000\000\000\000\000\000\003E\000\000\005\137\005\137\000\000\000\000\005\137\005\137\000\000\003E\000\000\003E\006)\000\000\003E\006)\000\000\000\000\000\000\003E\003E\003E\000\000\000\000\000\000\005\137\006)\000\000\000\000\000\000\006)\000\000\006)\000\000\000\000\003E\005\137\000\000\000\000\003E\000\000\000\000\000\000\000\000\006)\000\000\000\000\000\000\000\000\000\000\006)\000\000\003E\003E\r\"\000\000\003E\003E\000\000\006)\000\000\006)\000\000\000\000\006)\000\000\000\000\000\000\000\000\006)\006)\000\238\000\000\000\000\rB\003E\000\000\011\229\000\000\001\006\011\229\000\000\000\000\028\142\000\000\006)\000\000\000\000\028\146\006)\000\000\011\229\000\000\000\000\000\000\000\000\000\000\011\229\000\000\000\000\000\000\000\000\006)\006)\r\230\000\000\006)\006)\000\000\011\229\000\000\000\000\000\000\000\000\000\000\011\229\000\000\000\000\006)\000\000\000\000\000\000\001\186\002N\011\229\006)\011\229\001\174\000\000\011\229\002\182\000\000\000\000\000\000\011\229\000\000\006)\000\000\000\000\000\000\000\000\003N\028\150\001B\001\006\004\149\000\000\003R\001\"\000\000\011\229\000\000\000\000\001&\011\229\000\000\000\000\000\000\000\000\003^\006r\000\000\000\000\001*\000\000\011\170\028\154\011\229\011\229\000\000\001F\011\229\000\000\000\000\003\226\000\000\020\226\000\000\000\000\0126\000\000\000\000\000\000\001R\012>\000\000\000\000\001^\002N\000\000\011\229\007\138\000\000\000\000\000\000\003F\007!\000\000\003\246\007!\012F\000\000\003\250\000\000\004\002\005b\000\000\005n\000\000\000\000\007!\000\000\000\000\000\000\007!\000\000\007!\012Z\012\158\005r\000\000\004\149\004\149\000\000\000\000\000\000\000\000\000\000\007!\005z\000\000\005~\000\000\005\190\007!\b\006\000\000\000\000\000\000\000\000\018\002\000\000\000\000\007!\000\000\007!\001\209\000\000\007!\001\209\000\000\000\000\000\000\007!\007!\000\238\005\130\000\000\000\000\000\000\001\209\000\000\004j\000\000\001\209\000\000\001\209\000\000\000\000\007!\000\000\000\000\000\000\007!\000\000\000\000\000\000\000\000\001\209\000\000\000\000\000\000\000\000\000\000\001\209\000\000\007!\007!\000\000\000\000\007!\007!\000\000\001\209\000\000\001\209\006-\000\000\001\209\006-\000\000\000\000\000\000\001\209\001\209\000\000\000\000\000\000\000\000\007!\006-\000\000\000\000\000\000\006-\000\000\006-\000\000\000\000\001\209\000\000\000\000\000\000\001\209\000\000\000\000\000\000\000\000\006-\000\000\000\000\000\000\000\000\000\000\006-\000\000\001\209\001\209\000\000\000\000\001\209\001\209\000\000\006-\000\000\006-\000\000\000\000\006-\000\000\000\000\000\000\001\209\006-\006-\000\238\000\000\000\000\000\000\001\209\000\000\000\000\000\000\000\000\r\198\000\000\000\000\000\000\000\000\006-\001\209\000\000\000\000\006-\000\000\000\000\000\000\000\000\b1\b1\000\000\000\000\000\000\b1\000\000\000\000\006-\006-\b1\000\000\006-\006-\000\000\000\000\003\238\000\000\000\000\000\000\b1\000\000\000\000\000\000\006-\000\000\000\000\b1\000\000\000\000\000\000\006-\000\000\004\129\000\000\000\000\004\129\000\000\000\000\000\000\b1\000\000\006-\000\000\b1\b1\000\000\004\129\000\000\000\000\000\000\004\129\b1\004\129\004\129\b1\000\000\000\000\000\000\b1\000\000\b1\b1\000\000\b1\004\129\000\000\000\000\000\000\004\129\000\000\004\129\000\000\000\000\000\000\000\000\b1\000\000\004>\000\000\004\129\000\000\004\129\004\129\000\000\004\129\b1\000\000\b1\004\129\004\129\011\146\000\000\000\000\000\000\000\000\000\000\000\000\004\129\000\000\004\129\000\000\000\245\004\129\000\000\000\245\004\129\000\000\004\129\011\146\004\129\000\000\000\000\b1\000\000\000\000\000\245\000\000\000\000\b1\000\245\000\000\000\245\004\129\004\129\000\000\000\000\004\129\004\129\000\000\000\000\000\000\000\000\000\000\000\245\004J\000\000\000\000\000\000\007\182\000\245\004\129\004\129\000\000\000\000\004\129\004\129\000\000\000\000\000\245\000\000\000\245\000\249\000\000\000\245\000\249\000\000\004\129\000\000\000\245\000\245\000\238\000\000\000\000\004\129\000\000\000\249\000\000\000\000\026v\000\249\000\000\000\249\000\000\000\000\000\245\000\000\000\000\000\000\000\245\000\000\000\000\000\000\000\000\000\249\000\000\000\000\000\000\000\000\000\000\000\249\000\000\000\245\000\245\000\000\000\000\000\245\000\245\000\000\000\249\000\000\000\249\000\000\000\000\000\249\000\000\000\000\000\000\000\000\000\249\000\249\000\238\000\000\000\000\000\000\000\245\000\000\000\000\002Z\003\"\000\000\000\000\000\000\001\"\000\000\000\249\000\245\000\000\000\000\000\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001*\002\134\002r\003&\000\249\000\249\000\000\000\000\000\249\000\249\002~\000\000\000\000\000\000\000\000\000\000\000\000\007\029\000\000\000\000\007\029\000\000\000\000\000\000\003*\003.\000\000\000\249\000\000\000\000\003:\007\029\003F\004\026\004&\007\029\000\000\007\029\000\249\r\158\000\000\r\162\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\029\000\000\000\000\000\000\000\000\000\000\007\029\0046\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\029\000\000\007\029\006!\005~\007\029\006!\000\000\000\000\000\000\007\029\007\029\000\000\000\000\012\138\000\000\r\174\006!\000\000\000\000\000\000\006!\000\000\006!\000\000\000\000\007\029\000\000\000\000\000\000\007\029\000\000\000\000\r\178\000\000\006!\000\000\000\000\000\000\000\000\000\000\006!\000\000\007\029\007\029\011\190\000\000\007\029\007\029\000\000\006!\000\000\006!\011\145\000\000\006!\011\145\000\000\000\000\000\000\006!\006!\000\000\014\206\000\000\000\000\007\029\011\145\000\000\000\000\000\000\011\145\000\000\011\145\000\000\000\000\006!\000\000\000\000\000\000\006!\000\000\000\000\000\000\000\000\011\145\000\000\000\000\000\000\000\000\000\000\011\145\000\000\006!\006!\000\000\000\000\006!\006!\000\000\011\145\000\000\011\145\000\000\000\000\011\145\000\000\000\000\000\000\000\000\011\145\000\000\000\000\000\000\000\000\000\000\006!\000\000\011\149\000\000\000\000\011\149\000\000\000\000\000\000\000\000\011\145\n:\000\000\000\000\011\145\000\000\011\149\000\000\000\000\000\000\011\149\000\000\011\149\000\000\000\000\000\000\000\000\011\145\011\145\000\000\000\000\011\145\011\145\000\000\011\149\000\000\000\000\000\000\000\000\000\000\011\149\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\149\011\145\011\149\000\000\000\000\011\149\000\000\000\000\000\000\000\000\011\149\000\000\011.\000\000\000\000\002Z\003\"\000\000\000\000\000\000\001\"\000\000\000\000\000\000\000\000\000\000\011\149\nJ\000\000\000\000\011\149\000\000\000\000\000\000\000\000\001*\002\134\002r\000\000\000\000\000\000\000\000\000\000\011\149\011\149\002~\000\000\011\149\011\149\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\003.\004Y\000\000\000\000\004Y\003:\011\149\003F\004\026\004&\000\000\000\000\000\000\000\000\r\158\004Y\026N\011.\000\000\004Y\000\000\004Y\007\138\000\000\000\000\000\000\000\000\005\145\000\000\000\000\005\145\0046\000\000\004Y\000\000\000\000\000\000\000\000\000\000\004Y\000\000\005\145\000\000\005~\000\000\005\145\000\000\005\145\004Y\000\000\004Y\000\000\000\000\004Y\000\000\026Z\000\000\000\000\004Y\005\145\000\000\000\000\000\000\000\000\000\000\005\145\b\006\000\000\000\000\000\000\000\000\000\000\r\178\000\000\004Y\000\000\000\000\000\000\004Y\005\145\000\000\000\000\000\000\000\000\005\145\005\145\000\238\000\000\000\000\000\000\000\000\004Y\004Y\000\000\000\000\004Y\004Y\000\000\000\000\000\000\005\145\000\000\000\000\000\000\000\000\000\000\004Q\000\000\000\000\004Q\000\000\000\000\000\000\004q\004Y\000\000\004q\005\145\005\145\000\000\004Q\005\145\005\145\000\000\004Q\012\006\004Q\004q\000\000\000\000\000\000\004q\000\000\004q\000\000\000\000\000\000\000\000\004Q\000\000\005\145\000\000\000\000\000\000\004Q\004q\000\000\000\000\000\000\000\000\000\000\004q\000\000\004Q\000\000\004Q\000\000\000\000\004Q\000\000\004q\000\000\004q\004Q\000\000\004q\000\000\000\000\000\000\000\000\004q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004Q\000\000\000\000\000\000\004Q\000\000\000\000\004q\000\000\000\000\000\000\004q\004A\000\000\000\000\004A\000\000\004Q\004Q\000\000\000\000\004Q\004Q\000\000\004q\004q\004A\000\000\004q\004q\004A\000\000\004A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004Q\000\000\000\000\000\000\004A\000\000\000\000\004q\000\000\000\000\004A\016\182\000\000\000\000\000\000\000\000\000\000\000\000\017\154\004A\000\000\004A\000\000\000\000\004A\000\000\000\000\000\000\000\000\004A\002Z\002^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\129\000\000\000\000\004\129\004A\000\000\003\254\000\000\004A\001*\002\134\002r\000\000\000\000\004\129\000\000\000\000\000\000\004\129\002~\004\129\004A\004A\000\000\000\000\004A\004A\000\000\000\000\000\000\000\000\000\000\004\129\002\130\003.\000\000\000\000\000\000\004\129\003:\000\000\003F\004\026\004&\004A\000\000\000\000\000\000\0042\000\000\011\245\000\000\004\129\011\245\000\000\020\182\000\000\004\129\011\146\007\165\000\000\000\000\000\000\000\000\011\245\0046\000\000\000\000\000\000\000\000\011\245\000\000\000\000\004\129\000\000\000\000\007\165\007\165\000\000\007\165\007\165\000\000\011\245\000\000\000\000\000\000\000\000\000\000\011\245\000\000\004\129\004\129\000\000\000\000\004\129\004\129\000\000\011\245\000\000\011\245\007\165\000\000\011\245\000\000\007\137\000\000\004f\011\245\004j\000\000\000\000\000\000\000\000\004\129\000\000\000\000\000\000\000\000\r\198\000\000\000\238\007\137\007\137\011\245\007\137\007\137\000\000\011\245\000\000\007\169\000\000\000\000\000\000\000\000\000\000\007\165\000\000\000\000\000\000\000\000\011\245\011\245\000\000\000\000\011\245\007\137\007\169\007\169\000\000\007\169\007\169\000\000\028~\007\165\000\000\007\165\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\245\000\000\007\137\000\000\000\000\007\157\007\165\007\169\000\000\005\222\007\165\000\000\000\000\000\000\007\165\000\000\007\165\007\137\004I\000\000\007\165\004I\007\157\007\157\000\000\007\157\007\157\000\238\000\000\000\000\000\000\000\000\004I\000\000\000\000\007\137\004I\007\137\004I\000\000\000\000\000\000\007\169\000\000\000\000\000\000\007\157\000\000\000\000\000\000\004I\007\137\002Z\002^\005\222\007\137\004I\000\000\000\000\007\137\007\169\007\137\007\169\000\000\000\000\007\137\000\238\000\000\000\000\000\000\004I\000\000\001*\002\134\002r\004I\007\169\000\000\000\000\005\222\007\169\007\157\002~\000\000\007\169\015\162\007\169\000\000\000\000\000\000\007\169\004I\000\000\000\000\000\000\000\000\002\130\016\246\000\000\007\157\016\026\007\157\003:\000\000\003F\004\026\004&\000\000\004I\004I\000\000\017\006\004I\004I\000\000\0062\000\000\000\000\005\222\007\157\000\000\004y\000\000\007\157\004y\007\157\000\000\000\000\0046\007\157\001\174\004I\000\000\002\182\000\000\004y\000\000\000\000\000\000\004y\000\000\004y\017B\000\000\028\214\000\000\002Z\002^\000\000\000\000\003R\000\000\000\000\004y\000\000\000\000\000\000\000\000\000\000\004y\000\000\000\000\003^\000\000\000\000\000\000\001*\002\134\011\170\000\000\000\000\000\000\000\000\004y\000\000\000\000\000\000\003\226\004y\020\226\000\000\000\000\0126\000\000\000\000\000\000\000\000\012>\006\241\006\241\002\130\003>\000\000\000\000\004y\000\000\003:\000\000\003F\004\026\004&\000\000\000\000\012F\000\000\0042\000\000\028\134\006\241\006\241\006\241\004y\004y\000\000\000\000\004y\004y\000\000\006\241\000\000\012Z\012\158\0046\000\000\004\189\000\000\005\005\000\000\012\217\012\217\000\000\000\000\006\241\006\241\004y\000\000\000\000\000\000\006\241\000\000\006\241\006\241\006\241\018\002\000\000\017\194\025\246\006\241\012\217\012\217\012\217\007\158\000\000\000\000\000\000\000\000\001\174\000\000\012\217\r\130\000\000\000\000\000\000\000\000\006\241\000\000\000\000\000\000\000\000\000\000\014\142\000\000\012\217\012\217\004\137\000\000\003R\000\000\012\217\000\000\012\217\012\217\012\217\001\174\000\000\000\000\002\182\012\217\014\146\002Z\002^\024\234\000\000\000\000\014\186\000\000\000\000\004\181\000\000\000\000\000\000\000\000\000\000\003R\012\217\000\000\000\000\000\000\0126\001*\002b\002r\004\222\012>\000\000\003^\000\000\000\000\000\000\002~\000\000\011\170\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015N\003\226\000\000\020\226\002\130\003.\0126\000\000\000\000\000\000\003:\012>\003F\004\026\004&\000\000\000\000\012Z\015b\0042\000\000\004\137\004\137\000\000\000\000\000\000\000\000\012F\002Z\002^\000\000\000\000\000\000\000\000\000\000\000\000\0046\000\000\000\000\000\000\015r\000\000\000\000\000\000\012Z\012\158\000\000\000\000\001*\002b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\018\002\000\000\000\000\000\000\000\000\002\130\0036\000\000\000\000\000\000\000\000\003:\000\000\003F\004\026\004&\000\000\000\000\000\000\000\000\0042\000\000\012\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0046")) + ((16, "o\248x\028r\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\022\150r\202\000\000\000\000\021\164r\202o\248\024\164\000/\001B\171\176\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0009\002x\000\177\000\000\000>\005\208\000\000\004\152\000\214\t\192\000\000\005\014\001\134\n\188\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\002\000\000\000\000\002`\187,\000\000\000\000\000\000\005\244\000\000\000\000\164\026\003:\004\182\000\000\000\000\185R\005\244\000\000v\002\021\164rB\169\228\021\164v\142s\234\021\164z\222\000\000\002\012\000\000q\186\003\b\000\000\027V\000\000\025\192\000\000\000\000\006\248\000\000\005\244\000\000\000\000\000\000\000Z\000\000\027V\000\000\007\142\197\158\203*\179\246\000\000\204\150\185R\000\000x\206\170\132\000\000pdn\138\187,r\202o\248\000\000\000\000s\234\021\164\127`q\186\007\236\197\158\000\000\194\004r\202o\248x\028\021\164\000\003\000\000\017\182w\162\021lnN\166&\000\000\000\023\000\000\000\000\003B\000\000\000\000t\168\001 \025\248\000\242\000\t\000\000\000\000\004n\000\000rB\006\238\007D\021\164\022\242\000\000\021\164o\248o\248\000\000\000\000\000\000t\210t\210\021\164\022\242nH\021\164\128.\030\028\004\140\b\232\000\000\007F\t\190\000\000\000\000\000\000\000\000\000\000\021\164\000\000\000\000\000\000x\028\021\164\000\003l.\184$y\192\000\250\128\240\166&\198,\192\142\000\000\b\232\000\000\bJ\000\000\023B\176\166\206\004\000\000\176\166\206\004\000\000\176\166\176\166\003\000\000X\003\000\005D\000\000\006x\000\000\000\000\006x\000\000\000\000\000\000\176\166\005\244\000\000\000\000\165\138\176\166\164\210\170\132\000\000\006\230\006x\185R\170\132\bB\176\166\000\000\000\000\000\000\000\000\000\000\000\000\129\162\170\132\130\150\003\000\000\000\000\000\000\000\001r\000\000\000\000\167\228\b\172\005\244\000\000\000\000\131\138\000\000\000\000\000\000\002\024\000\000\176\166\000\000\001\002\185\240\000\000\176\166\001\002\176\166o2\000\000p\"\000\000\006\234\004 \000\000\b&\176\166\006\144\000\000\007V\000\000\006f\000\000\000\003\tV\000\000\000\000\000\000\024\002\022\186\166&w\182\021\164\166&\000\000\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\174\028\182\000\000\000\000\000\000\001\244\029p\192\142\000\000w\182\021\164\166&\000\000\000\000\208\172\166&\2092\166&\209L\000\000\166&\000\000\000\000\167\018t\168\005\140\005\140\000\000\tL\166&\000\000\000\000\000\000\004\212\tl\000\000\025\214\000\000\166&\209\140\176\166\nN\000\000\166&\209\204\001B\000\000\000\000\000\000\t\182\000\000\030\194\000\000\198,\000\000\t\198\000\000n\186\196\224\000\000\000\000\024\218\005d\023.\t\210\000\000\000\000\000\000\000\000\tL\000\000\168\180\007*\t\230\000\019\176\166\003j\nH\000\000\000\000\n\"\t\230\001\162\000\003x\028xlt\210\021\164\022\242\000/\006\244\000\t\000\000\t\250rBrB\n\152rB\000/\006\244\n\166\000\000\n\180rB\000\000\184\138\n*q\186\b\232\002@\186\142\000\000\176\166\180\148\176\166\172Z\181L\176\166\b\148\176\166\181\128\000\000\0114\n\146\nxrB\185(\000\000\n\192\tz\170\006\000\000\000\000\000\000\000\000rB\185\198rB\186d\002\152\003\000\173\018\t\190\003\000\173\176\000\000\187\002\n*\000\000\000\000\187\160\000\156\000\000\024x\000\000\011F\022\242\000\000\170\164nH\000\000\000\228\000\000rB\024\206\000\000\000\000\000\000\169F\000\000\000+\000\003y\192\011~\022\180\132\\\023\136|4\017\182\133\030x\028\021\164\017\182x\028\021\164p\232x\028\021\164\000\003w\182\021\164\192\142\166&p\152\000\003x\028\021\164s\186\004\144\000\000\166&\024\218\176\166\004f\001\162\011\128\000\000\000\000\000\000u\154\005\140\011\194\000\000\166&\000\000\000\000\174>\000\000\000\000\004B\170\132\003\000\011\176\133\224w\182\021\164\192\142\027x\134\162w\182\021\164\192\142\028t\166&\000\000\000\000w\182\021\164\166&\025\214\000\003\017\182\000\000\000\000\000\000\000\000\001\246\026|m\"\000\000{\152|Zt\210\021\164\022\242\005\208rB\027\212\000\000}\028}\222\200\148\023\222\176\166\011J\000\003x\028\021\164\017\182\023\136\017\182\002\242\023Rv\142w\182\021\164\192\142\025\006v\142\135dw\182\021\164\192\142\000\000\017\182\011\028\011\202\002\226\176\166&\162\176\166\027\132\176\166'T\012\n\000\000\000\000\012\006\000\000\017\182\003\238\012&\000\000\030l\000\003\012|\000\000\029p\136&w\182\021\164\192\142\030l\018\178\024\132\000\000\000\000\000\000\000\000\n>\000\003\000\000\000\000\031h\136\232w\182\021\164\192\142 d!`\137\170w\182\021\164\192\142\"\\#X\000\000\019\174\025\128\138lw\182\021\164\192\142\000\000\000\000\000\003r\202\000\003\000\000\000\000\139.w\182\021\164\192\142$T%P\139\240w\182\021\164\192\142&L'H\140\178w\182\021\164\192\142(D)@\141tw\182\021\164\192\142*<+8\1426w\182\021\164\192\142,4-0\142\248w\182\021\164\192\142.,/(\143\186w\182\021\164\192\1420$1 \144|w\182\021\164\192\1422\0283\024\145>w\182\021\164\192\1424\0205\016\146\000w\182\021\164\192\1426\0127\b\146\194w\182\021\164\192\1428\0049\000\147\132w\182\021\164\192\1429\252:\248\148Fw\182\021\164\192\142;\244<\240\149\bw\182\021\164\192\142=\236>\232\149\202w\182\021\164\192\142?\228@\224\150\140w\182\021\164\192\142A\220B\216\151Nw\182\021\164\192\142C\212D\208\152\016w\182\021\164\192\142E\204F\200\152\210w\182\021\164\192\142G\196H\192\153\148w\182\021\164\192\142I\188J\184\021\164\166&s\186\000\003\000\000\187,\005\140\012\004\176\166\011\196\000\003\000\000\001\202\005\244\000\000\176\166\012$\000\003\000\000\012\026\000\003\000\000\000\000\002\226\000\000\012.\133\224\000\000\000\000\000\000\027\206\176\166\012\132\000\003\000\000\031\190\000\003\000\000\166& \186\166&!\182\166&\"\178\001B\000\000\000\000\000\000#\174\166&$\170\000\000\194\004\1940\000\000\000\000\000\000K\180\000\003\012\214\000\000\000\003\012\250\000\000\b\228\025\200v\142\r\186\000\000\171(wZ\000\000v\142\r\236\000\000v\142\r\252\000\000\000\000\017\182\004\234\026\196v\142\014>\005\230\154Vw\182\021\164\192\142L\176M\172v\142\014F\006\226\155\024w\182\021\164\192\142N\168O\164v\142\014R\007\222\155\218w\182\021\164\192\142P\160Q\156\030\250\000\003\014\162\b\218\156\156w\182\021\164\192\142R\152S\148\000\003\014\202\t\214\157^w\182\021\164\192\142T\144U\140\000\003\014\230\n\210\158 w\182\021\164\192\142V\136W\132\n\166\027\000v\142\014\248\011\206\158\226w\182\021\164\192\142X\128Y|v\142\014\250\012\202\159\164w\182\021\164\192\142Zx[tv\142\015\006\r\198\160fw\182\021\164\192\142\\p]l\014\194\161(w\182\021\164\192\142^h_d\015\190\020\170\000\000\000\000\000\000\000\000\015B\000\000v\142\015B\000\000v\142\015B\000\000\000\000%\166\000\003\000\000\007 \000\003\000\000\166&\000\000\000\000\188<\015T\000\000~\160\000\000\014\164\000\000\127l\000\000\015f\000\000\011~\015\018\000\000\023\136\026b\b\232\000\000\022N\024\190\011\202\026\130\000\000\000\000\015\148\000\000\001\146\027x|\246\000\000\012*\000\000\000\000\000\003\014\242\000\003\014\248\000\000``\000\000\015z\000\003\000\000\000\003\000\000\000\000\000\000a\\\015\192\161\234w\182\021\164\192\142bX\162\172w\182\021\164\192\142cTdPeL\163nw\182\021\164\192\142fHgD\000\000\015\"\000\000\026|w\182\021\164\192\142\004p\000\000\171(\000\000\016\186\015\186\000\000w\182\021\164\192\142\030\240\182\012\011\246\r\\\000\000\000\000\015P\000\000\015\202\000\000\000\000\021\164\022\242\003\198\000\003\000\000\025\248\000\242\000\t\006\244\022\242\198\146rB\003\158\022\242\198\246\015p\000\003\000\000\006\244\000\000r\226\021f\022V\000\000\012P\015\228\000\000\015\228\002\172\180\018\006.\000\000\015\186\015B\187,\003\220\176\166\023\004\bX\012\238\004\014\000\000\027\152\015\248\000\000\007\218\000\000\000\000\016\014\170\132\174\212\000\000\182d\202\172\005\234\180\018\015\218\170\132\188\210\1758\015\234\170\132\1896\175\216\003\216\015\192\000\003\000\000\000\000\021\164\201,\000\000\166&\194\004\000\000\000\000\0166\000\000\000\000\000\000w\182\021\164\192\142h@i<\000\000\015~\000\000\000\000t\210\021\164\022\242\003\216\000\000rB\028h\000\000\005\180\000\000\016@\000\000\016h\192\142j8w\182\021\164\192\142\024\172\000\000rB\028j\000\000rB\026r\000\000rB\029\204\000\000\182\234\000\000rB\030b\000\000rB\029f\000\000rB\031\\\000\000\1940\000\000\021\164\022\242\1940\000\000\030d\030\028\004\140\005\244\205\014rB\201l\194\004\000\000\000\242\005\222\000\t\006\244\194\004\206\130\000\242\000\t\006\244\194\004\206\130\000\000\000\000\006\244\194\004\000\000r\202o\248\166&\023\186\000\003\000\000r\202o\248t\210\021\164\022\242\1940\000\000\024\164\000/\001B\015\140\187,\t\218\176\166\194\198\015\192\016j\205l\000\000\194\004\000\000\195Hr\226\021f\022V\199T\028\196\012\166\001\250\r\n\015\176\021\164\194\004\000\000\021\164\194\004\000\000\176\166\176\166\020\208\006&\000\240\003\000\206\220\000\000\000\240\003\000\206\220\000\000\030\146\030\028\004\140\005\244\207:rB\1940\000\000\000\242\007\214\026\014\003\000\206\220\000\000\000\t\015\180rB\1940\130\030\000\242\000\t\015\208rB\1940\130\030\000\000\000\000\007\240\000\003\194h\000\000rB\205\198\194\004\000\000\007\240\000\000v\002\021\164rB\1940\000\000r\226\021f\022V\188\018\242\000\000\018\246\000\000q\216q\216\189p\189p\000\000\000\000{L\189p\000\000\000\000\000\000{L\189p\018f\000\000\018h\000\000"), (16, "\003\165\000\006\003.\0032\003\165\002\170\002\174\003\165\002\218\002z\003\165\0041\003\165\001^\002\230\003\165\007&\003\165\003\165\003\165\001V\003\165\003\165\003\165\001\194\004\241\004\241\b2\002\234\003\165\003f\003j\011\030\003\165\001n\003\165\001~\002\238\000\238\003\138\000\238\003\165\003\165\003\190\003\194\003\165\003\198\003\210\003\222\003\230\007\006\001f\003\165\003\165\002\162\bb\003\006\003\218\003\165\003\165\003\165\bf\bj\bv\b\134\002^\005\138\003\165\003\165\003\165\003\165\003\165\003\165\003\165\003\165\003\165\b\158\003\n\003\165\007^\003\165\003\165\003\165\0041\b\170\b\194\tf\005\150\005\154\003\165\003\165\003\165\0042\003\165\003\165\003\165\003\165\b~\b\022\b\130\b\149\016\210\003\165\006\226\003\165\003\165\004\241\003\165\003\165\003\165\003\165\003\165\003\165\005\158\b\146\003\165\003\165\003\165\tz\004^\t\222\007\218\003\165\003\165\003\165\003\165\r9\004\241\004\241\001v\r9\r9\r9\r9\b>\r9\r9\r9\r9\000\238\r9\r9\004\241\r9\r9\r9\004J\r9\r9\r9\r9\004\241\r9\002b\r9\r9\r9\r9\r9\r9\r9\r9\b2\r9\0079\r9\005\014\r9\r9\r9\r9\r9\030\147\r9\r9\000\238\r9\003\226\r9\r9\r9\000\238\000\238\r9\r9\r9\r9\r9\r9\r9\000\238\r9\r9\r9\r9\r9\r9\r9\r9\r9\r9\r9\001\137\r9\r9\004\206\r9\r9\r9\001\002\001\174\003\006\004\241\r9\r9\r9\r9\r9\001\134\r9\r9\r9\r9\r9\r9\r9\bB\r9\r9\007\193\r9\r9\003\n\r9\r9\r9\r9\r9\r9\r9\r9\r9\r9\r9\r9\r9\000\238\004\241\r9\r9\r9\r9\001\137\001\137\005\030\rB\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\r\t\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\r\t\001\137\004\254\001\137\022\014\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\007\002\001\137\016\142\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\rJ\001\137\001\137\001\137\001Z\004\t\006\133\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\005\206\t\146\001\137\020\170\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\001\137\n\237\018\018\007n\002\030\n\237\n\237\n\237\n\237\005\002\n\237\n\237\n\237\n\237\001\190\n\237\n\237\r\r\n\237\n\237\n\237\007v\n\237\n\237\n\237\n\237\003\205\n\237\001\170\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\r\r\n\237\001\182\n\237\003\205\n\237\n\237\n\237\n\237\n\237\007\230\n\237\n\237\007\153\n\237\t\129\n\237\n\237\n\237\002\146\007\238\n\237\n\237\n\237\n\237\n\237\n\237\n\237\007\242\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\018r\n\237\n\237\0045\n\237\n\237\n\237\007\201\001\218\004\186\007^\n\237\n\237\n\237\n\237\n\237\000\238\n\237\n\237\n\237\n\237\n\237\t\246\n\237\n6\nr\n\237\n>\n\237\n\237\003\018\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\000\238\n\237\n\237\n\237\n\237\n\237\004Q\003\022\007\218\002*\004Q\004Q\004Q\004Q\019\018\004Q\004Q\004Q\004Q\t\129\004Q\004Q\rB\004Q\004Q\004Q\000\238\004Q\004Q\004Q\004Q\0045\004Q\b2\004Q\004Q\004Q\004Q\004Q\004Q\004Q\004Q\b2\004Q\004\241\004Q\000\238\004Q\004Q\004Q\004Q\004Q\005:\004Q\004Q\000\238\004Q\017\210\004Q\004Q\004Q\017\170\004\241\004Q\004Q\004Q\004Q\004Q\004Q\004Q\004\241\004Q\004Q\004Q\004Q\004Q\004Q\004Q\004Q\004Q\004Q\004Q\000\238\t\238\nj\004\173\004Q\004Q\004Q\003:\007\149\004\241\b\210\004Q\004Q\004Q\004Q\004Q\018.\004Q\004Q\004Q\004Q\004Q\t\246\004Q\019\022\nr\004Q\001Z\004Q\004Q\004\t\004Q\004Q\004Q\004Q\004Q\004Q\004Q\004Q\004Q\004Q\004Q\004Q\004Q\000\238\004Q\004Q\004Q\004Q\004Q\004A\004\241\b\214\b\242\004A\004A\004A\004A\007E\004A\004A\004A\004A\000\238\004A\004A\t\169\004A\004A\004A\017N\004A\004A\004A\004A\004\173\004A\t&\004A\004A\004A\004A\004A\004A\004A\004A\001Z\004A\b2\004A\004\t\004A\004A\004A\004A\004A\tF\004A\004A\003>\004A\000\238\004A\004A\004A\003\018\tZ\004A\004A\004A\004A\004A\004A\004A\004:\004A\004A\004A\004A\004A\004A\004A\004A\004A\004A\004A\003\022\t\238\nj\006\178\004A\004A\004A\005Y\030\131\001\222\024\250\004A\004A\004A\004A\004A\0042\004A\004A\004A\004A\004A\t\246\004A\006\153\nr\004A\n6\004A\004A\n>\004A\004A\004A\004A\004A\004A\004A\004A\004A\004A\004A\004A\004A\019&\004A\004A\004A\004A\004A\n\141\003.\0032\006\030\n\141\n\141\n\141\n\141\007\005\n\141\n\141\n\141\n\141\001\202\n\141\n\141\019\230\n\141\n\141\n\141\004>\n\141\n\141\n\141\n\141\0222\n\141\rB\n\141\n\141\n\141\n\141\n\141\n\141\n\141\n\141\b2\n\141\001\241\n\141\001j\n\141\n\141\n\141\n\141\n\141\b\201\n\141\n\141\000\238\n\141\014b\n\141\n\141\n\141\001\206\006\153\n\141\n\141\n\141\n\141\n\141\n\141\n\141\000\n\n\141\n\141\n\141\n\141\n\141\n\141\n\141\n\141\n\141\n\141\n\141\018\026\n\141\n\141\004B\n\141\n\141\n\141\n6\006y\005Z\n>\n\141\n\141\n\141\n\141\n\141\001\241\n\141\n\141\n\141\n\141\n\141\n\141\n\141\t\182\n\141\n\141\018z\n\141\n\141\005J\n\141\n\141\n\141\n\141\n\141\n\141\n\141\n\141\n\141\n\141\n\141\n\141\n\141\004\134\004N\n\141\n\141\n\141\n\141\n\157\022\002\004\014\004\026\n\157\n\157\n\157\n\157\004&\n\157\n\157\n\157\n\157\003F\n\157\n\157\002F\n\157\n\157\n\157\005^\n\157\n\157\n\157\n\157\t\173\n\157\002\017\n\157\n\157\n\157\n\157\n\157\n\157\n\157\n\157\002J\n\157\022\n\n\157\021\202\n\157\n\157\n\157\n\157\n\157\006\129\n\157\n\157\0042\n\157\014\134\n\157\n\157\n\157\005\002\007\"\n\157\n\157\n\157\n\157\n\157\n\157\n\157\000\238\n\157\n\157\n\157\n\157\n\157\n\157\n\157\n\157\n\157\n\157\n\157\005\002\n\157\n\157\005R\n\157\n\157\n\157\006\218\006\242\003J\t\173\n\157\n\157\n\157\n\157\n\157\001\190\n\157\n\157\n\157\n\157\n\157\n\157\n\157\017\194\n\157\n\157\004\130\n\157\n\157\016\014\n\157\n\157\n\157\n\157\n\157\n\157\n\157\n\157\n\157\n\157\n\157\n\157\n\157\017\202\t\173\n\157\n\157\n\157\n\157\n\149\003.\021\"\000\238\n\149\n\149\n\149\n\149\002n\n\149\n\149\n\149\n\149\001\190\n\149\n\149\0212\n\149\n\149\n\149\004)\n\149\n\149\n\149\n\149\003\158\n\149\016\022\n\149\n\149\n\149\n\149\n\149\n\149\n\149\n\149\030C\n\149\018\026\n\149\022.\n\149\n\149\n\149\n\149\n\149\006y\n\149\n\149\005\002\n\149\014\170\n\149\n\149\n\149\002\198\007\"\n\149\n\149\n\149\n\149\n\149\n\149\n\149\0226\n\149\n\149\n\149\n\149\n\149\n\149\n\149\n\149\n\149\n\149\n\149\004\002\n\149\n\149\004\241\n\149\n\149\n\149\004\241\021\194\b\193\025B\n\149\n\149\n\149\n\149\n\149\004\146\n\149\n\149\n\149\n\149\n\149\n\149\n\149\021j\n\149\n\149\n6\n\149\n\149\n>\n\149\n\149\n\149\n\149\n\149\n\149\n\149\n\149\n\149\n\149\n\149\n\149\n\149\021v\000\238\n\149\n\149\n\149\n\149\n\129\025\026\004\222\r]\n\129\n\129\n\129\n\129\026\194\n\129\n\129\n\129\n\129\002\174\n\129\n\129\r]\n\129\n\129\n\129\002\210\n\129\n\129\n\129\n\129\000\238\n\129\005B\n\129\n\129\n\129\n\129\n\129\n\129\n\129\n\129\005\t\n\129\025\"\n\129\025\166\n\129\n\129\n\129\n\129\n\129\006y\n\129\n\129\000\238\n\129\014\210\n\129\n\129\n\129\003\150\007\146\n\129\n\129\n\129\n\129\n\129\n\129\n\129\025\174\n\129\n\129\n\129\n\129\n\129\n\129\n\129\n\129\n\129\n\129\n\129\006*\n\129\n\129\001\190\n\129\n\129\n\129\005f\005\t\b\185\007\190\n\129\n\129\n\129\n\129\n\129\006B\n\129\n\129\n\129\n\129\n\129\n\129\n\129\026\198\n\129\n\129\014\018\n\129\n\129\003\158\n\129\n\129\n\129\n\129\n\129\n\129\n\129\n\129\n\129\n\129\n\129\n\129\n\129\003\162\002\146\n\129\n\129\n\129\n\129\n\137\029\254\001\206\006~\n\137\n\137\n\137\n\137\007\r\n\137\n\137\n\137\n\137\006\150\n\137\n\137\006\186\n\137\n\137\n\137\007\133\n\137\n\137\n\137\n\137\028\246\n\137\rB\n\137\n\137\n\137\n\137\n\137\n\137\n\137\n\137\003\166\n\137\0042\n\137\001z\n\137\n\137\n\137\n\137\n\137\006\206\n\137\n\137\007b\n\137\014\246\n\137\n\137\n\137\004^\006\222\n\137\n\137\n\137\n\137\n\137\n\137\n\137\004\241\n\137\n\137\n\137\n\137\n\137\n\137\n\137\n\137\n\137\n\137\n\137\006\238\n\137\n\137\006^\n\137\n\137\n\137\007\158\030c\006\250\018\214\n\137\n\137\n\137\n\137\n\137\004>\n\137\n\137\n\137\n\137\n\137\n\137\n\137\001\254\n\137\n\137\020j\n\137\n\137\000\238\n\137\n\137\n\137\n\137\n\137\n\137\n\137\n\137\n\137\n\137\n\137\n\137\n\137\000\238\004\206\n\137\n\137\n\137\n\137\n\133\n\182\004\241\007.\n\133\n\133\n\133\n\133\007\021\n\133\n\133\n\133\n\133\007:\n\133\n\133\001\206\n\133\n\133\n\133\003\201\n\133\n\133\n\133\n\133\007\"\n\133\007R\n\133\n\133\n\133\n\133\n\133\n\133\n\133\n\133\000\238\n\133\0042\n\133\001\138\n\133\n\133\n\133\n\133\n\133\007\170\n\133\n\133\r\014\n\133\015\026\n\133\n\133\n\133\002\174\007\162\n\133\n\133\n\133\n\133\n\133\n\133\n\133\007\210\n\133\n\133\n\133\n\133\n\133\n\133\n\133\n\133\n\133\n\133\n\133\0156\n\133\n\133\003\158\n\133\n\133\n\133\029\014\n.\nV\002\174\n\133\n\133\n\133\n\133\n\133\007\186\n\133\n\133\n\133\n\133\n\133\n\133\n\133\b&\n\133\n\133\022n\n\133\n\133\b\238\n\133\n\133\n\133\n\133\n\133\n\133\n\133\n\133\n\133\n\133\n\133\n\133\n\133\000\238\t\133\n\133\n\133\n\133\n\133\n\145\001\002\001\174\007\238\n\145\n\145\n\145\n\145\bn\n\145\n\145\n\145\n\145\t\006\n\145\n\145\016v\n\145\n\145\n\145\t\225\n\145\n\145\n\145\n\145\t\218\n\145\t2\n\145\n\145\n\145\n\145\n\145\n\145\n\145\n\145\000\238\n\145\017~\n\145\017\134\n\145\n\145\n\145\n\145\n\145\n2\n\145\n\145\nR\n\145\015F\n\145\n\145\n\145\000\238\016\158\n\145\n\145\n\145\n\145\n\145\n\145\n\145\025b\n\145\n\145\n\145\n\145\n\145\n\145\n\145\n\145\n\145\n\145\n\145\n^\n\145\n\145\003\162\n\145\n\145\n\145\t\133\002\134\b\185\r6\n\145\n\145\n\145\n\145\n\145\nn\n\145\n\145\n\145\n\145\n\145\n\145\n\145\t\201\n\145\n\145\000\238\n\145\n\145\n~\n\145\n\145\n\145\n\145\n\145\n\145\n\145\n\145\n\145\n\145\n\145\n\145\n\145\001\002\001\174\n\145\n\145\n\145\n\145\n\161\002\134\r.\r^\n\161\n\161\n\161\n\161\rR\n\161\n\161\n\161\n\161\rv\n\161\n\161\016\162\n\161\n\161\n\161\021\210\n\161\n\161\n\161\n\161\000\238\n\161\r\254\n\161\n\161\n\161\n\161\n\161\n\161\n\161\n\161\018>\n\161\003\162\n\161\004\029\n\161\n\161\n\161\n\161\n\161\014\n\n\161\n\161\018\002\n\161\015j\n\161\n\161\n\161\022:\r\146\n\161\n\161\n\161\n\161\n\161\n\161\n\161\025\170\n\161\n\161\n\161\n\161\n\161\n\161\n\161\n\161\n\161\n\161\n\161\022\006\n\161\n\161\020\174\n\161\n\161\n\161\025&\006\137\rq\021\242\n\161\n\161\n\161\n\161\n\161\006>\n\161\n\161\n\161\n\161\n\161\n\161\n\161\b\197\n\161\n\161\022\166\n\161\n\161\002b\n\161\n\161\n\161\n\161\n\161\n\161\n\161\n\161\n\161\n\161\n\161\n\161\n\161\000\238\bn\n\161\n\161\n\161\n\161\n\153\000\238\006}\007\238\n\153\n\153\n\153\n\153\025\030\n\153\n\153\n\153\n\153\014\030\n\153\n\153\re\n\153\n\153\n\153\022z\n\153\n\153\n\153\n\153\022\194\n\153\t\205\n\153\n\153\n\153\n\153\n\153\n\153\n\153\n\153\026n\n\153\025\178\n\153\0146\n\153\n\153\n\153\n\153\n\153\0042\n\153\n\153\014B\n\153\015\142\n\153\n\153\n\153\000\238\026R\n\153\n\153\n\153\n\153\n\153\n\153\n\153\028\186\n\153\n\153\n\153\n\153\n\153\n\153\n\153\n\153\n\153\n\153\n\153\028\242\n\153\n\153\014^\n\153\n\153\n\153\b\189\r\014\014\130\025\130\n\153\n\153\n\153\n\153\n\153\014\166\n\153\n\153\n\153\n\153\n\153\n\153\n\153\029\250\n\153\n\153\000\238\n\153\n\153\022\130\n\153\n\153\n\153\n\153\n\153\n\153\n\153\n\153\n\153\n\153\n\153\n\153\n\153\026F\028\n\n\153\n\153\n\153\n\153\n\221\026\166\005\133\014\206\n\221\n\221\n\221\n\221\025\226\n\221\n\221\n\221\n\221\001\190\n\221\n\221\022\130\n\221\n\221\n\221\007\238\n\221\n\221\n\221\n\221\014\242\n\221\007\238\n\221\n\221\n\221\n\221\n\221\n\221\n\221\n\221\000\238\n\221\029\002\n\221\015\022\n\221\n\221\n\221\n\221\n\221\015B\n\221\n\221\015f\n\221\015\170\n\221\n\221\n\221\028\134\015\138\n\221\n\221\n\221\n\221\n\221\n\221\n\221\001\190\n\221\n\221\n\221\n\221\n\221\n\221\n\221\n\221\n\221\n\221\n\221\030s\n\221\n\221\005\t\n\221\n\221\n\221\015\222\007\238\015\234\015\246\n\221\n\221\n\221\n\221\n\221\016*\n\221\n\221\n\221\n\221\n\221\n\221\n\221\016:\n\221\n\221\016J\n\221\n\221\029f\n\221\n\221\n\221\n\221\n\221\n\221\n\221\n\221\n\221\n\221\n\221\n\221\n\221\016V\002\210\n\221\n\221\n\221\n\221\004=\016\134\016\174\016\182\004=\004=\004=\004=\016\198\004=\004=\004=\004=\016\230\004=\004=\0176\004=\004=\004=\017b\004=\004=\004=\004=\017\142\004=\017\150\004=\004=\004=\004=\004=\004=\004=\004=\017\222\004=\018\006\004=\003\242\004=\004=\004=\004=\004=\018\"\004=\004=\018&\004=\018N\004=\004=\004=\018b\018\130\004=\004=\004=\004=\004=\004=\004=\018\146\004=\004=\004=\004=\004=\004=\004=\004=\004=\004=\004=\018\166\t\238\nj\018\210\004=\004=\004=\018\250\019.\0196\020b\004=\004=\004=\004=\004=\020v\004=\004=\004=\004=\004=\t\246\004=\020z\nr\004=\006z\004=\004=\021:\004=\004=\004=\004=\004=\004=\004=\004=\004=\004=\004=\004=\004=\021R\004=\004=\004=\004=\004=\nu\021\218\021\222\022\022\nu\nu\nu\nu\022\026\nu\nu\nu\nu\022B\nu\nu\022F\nu\nu\nu\022^\nu\nu\nu\nu\022\214\nu\023\006\nu\nu\nu\nu\nu\nu\nu\nu\023\n\nu\023.\nu\0232\nu\nu\nu\nu\nu\023B\nu\nu\023R\nu\023^\nu\nu\nu\023\146\023\150\nu\nu\nu\nu\nu\nu\nu\023\230\nu\nu\nu\nu\nu\nu\nu\nu\nu\nu\nu\024\014\t\238\nj\024\018\nu\nu\nu\024\"\024r\024\146\024\210\nu\nu\nu\nu\nu\024\246\nu\nu\nu\nu\nu\t\246\nu\025\006\nr\nu\025.\nu\nu\0252\nu\nu\nu\nu\nu\nu\nu\nu\nu\nu\nu\nu\nu\025>\nu\nu\nu\nu\nu\002!\025N\025j\025z\002!\002\170\002\174\002!\025\142\002z\002!\n*\002!\025\186\002\230\002!\025\190\002!\002!\002!\025\202\002!\002!\002!\001\194\025\218\nZ\025\238\002\234\002!\002!\002!\002!\002!\nb\002!\026\206\002\238\026\218\003\138\027\n\002!\002!\002!\002!\002!\027.\003\210\001\174\027V\002!\027\202\002!\002!\002\162\027\210\027\234\003\218\002!\002!\002!\bf\bj\bv\028\022\014J\005\138\002!\002!\002!\002!\002!\002!\002!\002!\002!\028\030\t\238\nj\028*\002!\002!\002!\0286\028\154\028\174\028\222\005\150\005\154\002!\002!\002!\028\230\002!\002!\002!\002!\b~\014R\b\130\029\030\014\194\002!\029F\002!\002!\029~\002!\002!\002!\002!\002!\002!\005\158\b\146\002!\002!\002!\tz\004^\029\146\029\170\002!\002!\002!\002!\n\201\029\182\029\190\029\199\n\201\002\170\002\174\n\201\029\215\002z\n\201\n\201\n\201\029\234\002\230\n\201\030\006\n\201\n\201\n\201\030#\n\201\n\201\n\201\001\194\0303\n\201\030O\002\234\n\201\n\201\n\201\n\201\n\201\n\201\n\201\030\163\002\238\030\191\003\138\030\202\n\201\n\201\n\201\n\201\n\201\030\255\003\210\001\174\031\019\n\201\031\027\n\201\n\201\002\162\031W\031_\003\218\n\201\n\201\n\201\bf\bj\bv\000\000\n\201\005\138\n\201\n\201\n\201\n\201\n\201\n\201\n\201\n\201\n\201\000\000\n\201\n\201\000\000\n\201\n\201\n\201\000\000\000\000\000\000\000\000\005\150\005\154\n\201\n\201\n\201\000\000\n\201\n\201\n\201\n\201\b~\n\201\b\130\000\000\n\201\n\201\000\000\n\201\n\201\000\000\n\201\n\201\n\201\n\201\n\201\n\201\005\158\b\146\n\201\n\201\n\201\tz\004^\000\000\000\000\n\201\n\201\n\201\n\201\n\197\000\000\000\000\000\000\n\197\002\170\002\174\n\197\000\000\002z\n\197\n\197\n\197\000\000\002\230\n\197\000\000\n\197\n\197\n\197\000\000\n\197\n\197\n\197\001\194\000\000\n\197\000\000\002\234\n\197\n\197\n\197\n\197\n\197\n\197\n\197\000\000\002\238\000\000\003\138\000\000\n\197\n\197\n\197\n\197\n\197\000\000\003\210\001\174\000\000\n\197\000\000\n\197\n\197\002\162\000\000\000\000\003\218\n\197\n\197\n\197\bf\bj\bv\000\000\n\197\005\138\n\197\n\197\n\197\n\197\n\197\n\197\n\197\n\197\n\197\000\000\n\197\n\197\000\000\n\197\n\197\n\197\000\000\000\000\000\000\000\000\005\150\005\154\n\197\n\197\n\197\000\000\n\197\n\197\n\197\n\197\b~\n\197\b\130\000\000\n\197\n\197\000\000\n\197\n\197\000\000\n\197\n\197\n\197\n\197\n\197\n\197\005\158\b\146\n\197\n\197\n\197\tz\004^\000\000\000\000\n\197\n\197\n\197\n\197\002i\000\000\000\000\000\000\002i\002\170\002\174\002i\000\000\002z\002i\n*\002i\000\000\002\230\002i\000\000\002i\002i\002i\000\000\002i\002i\002i\001\194\001\241\nZ\000\000\002\234\002i\002i\002i\002i\002i\nb\002i\000\000\002\238\000\000\003\138\000\000\002i\002i\002i\002i\002i\000\000\003\210\001\174\000\000\002i\000\n\002i\002i\002\162\000\000\000\000\003\218\002i\002i\002i\bf\bj\bv\000\000\014J\005\138\002i\002i\002i\002i\002i\002i\002i\002i\002i\000\000\000\000\002i\001\241\002i\002i\002i\004\241\000\000\000\000\000\000\005\150\005\154\002i\002i\002i\000\000\002i\002i\002i\002i\b~\000\000\b\130\004\241\004\241\002i\004\241\002i\002i\004\241\002i\002i\002i\002i\002i\002i\005\158\b\146\002i\002i\002i\tz\004^\004\241\004\241\002i\002i\002i\002i\004\241\000\000\004\241\004\241\004\241\004\241\004\241\004\241\004\241\000\000\004\241\020\214\004\241\004\241\000\238\004\241\004\241\004\241\004\241\004\241\004\241\004\241\004\241\004\241\004\241\004\241\004\241\004\241\000\238\004\241\004\241\000\238\004\241\004\241\004\241\000\238\004\241\004\241\004\241\004\241\004\241\000\000\004\241\004\241\004\241\004\241\004\241\004\241\004\241\004\241\001\241\004\241\004\241\004\241\004\241\004\241\004\241\004\241\004\241\000\238\004\241\004\241\004\241\004\241\004\241\004\241\004\241\004\241\004\241\000\000\004\241\000\000\024\234\004\241\004\241\004\241\004\241\004\241\000\000\000\n\000\238\004\241\004\241\004\241\004\241\004\241\004\241\004\241\004\241\004\241\000\000\000\000\004\241\004\241\017\250\001\241\004\241\002z\004\241\004\241\000\000\000\000\007\201\ti\004\241\004\241\007\201\001\241\001\241\004\241\000\000\004\241\004\241\004\241\000\000\000\000\004\241\004\241\004\241\004\241\000\000\000\129\004\241\000\129\000\129\000\129\000\129\000\129\000\129\000\129\004\241\000\129\000\000\000\129\000\129\017\254\000\129\000\129\026\014\000\000\000\129\000\129\000\238\000\129\000\129\000\129\000\129\000\000\000\129\018\n\000\129\000\129\000\000\007\165\000\129\000\129\007\185\000\129\000\129\000\129\007\185\000\129\000\000\000\129\000\129\000\129\000\129\000\129\000\129\000\129\000\129\003R\002\174\000\129\000\129\007\201\005\154\000\129\000\129\003V\000\129\000\129\000\129\000\129\000\129\000\129\000\129\000\129\000\129\ti\001\194\000\129\n6\b\173\000\129\n>\000\129\b\173\000\129\t\173\025Z\006\182\002\174\000\129\000\129\000\129\000\129\000\129\000\129\000\129\000\129\000\000\000\000\003~\000\129\007\165\000\000\000\129\005]\000\129\002\162\000\222\000\000\000\000\007\157\000\129\br\000\000\007\157\005z\000\000\000\129\000\129\000\129\000\129\b\173\000\000\000\129\000\129\000\129\000\129\002a\000\000\000\000\003\150\002a\002\170\002\174\002a\007\026\002z\002a\000\000\002a\000\000\002\230\002a\b\173\002a\002a\002a\t\250\002a\002a\002a\001\194\000\000\000\000\020.\002\234\002a\002a\002a\002a\002a\015\226\002a\015\238\002\238\000\000\003\138\000\000\002a\002a\002a\002a\002a\b\153\003\210\bz\000\000\002a\000\000\002a\002a\002\162\004\218\007\157\003\218\002a\002a\002a\bf\bj\bv\000\000\000\000\005\138\002a\002a\002a\002a\002a\002a\002a\002a\002a\004\n\t\238\nj\007\161\002a\002a\002a\007\161\000\000\000\238\000\000\005\150\005\154\002a\002a\002a\000\000\002a\002a\002a\002a\b~\t\246\b\130\000\000\nr\002a\bY\002a\002a\000\000\002a\002a\002a\002a\002a\002a\005\158\b\146\002a\002a\002a\tz\004^\007^\000\238\002a\002a\002a\002a\002u\004\241\000\000\000\000\002u\000\000\006N\002u\bY\005\250\002u\000\000\002u\b\030\000\000\002u\006b\002u\002u\002u\006j\002u\002u\002u\bY\000\000\007\161\bY\t\210\002u\002u\002u\002u\002u\bY\002u\007\218\007^\bY\019N\000\000\002u\002u\002u\002u\002u\000\000\007\165\000\n\000\000\002u\007\165\002u\002u\000\238\000\238\bJ\000\000\002u\002u\002u\007\189\004\169\001\241\001\241\007\189\000\000\002u\002u\002u\002u\002u\002u\002u\002u\002u\001\241\t\238\nj\007\218\002u\002u\002u\n\014\t\185\000\000\t\185\t\185\000\000\002u\002u\002u\000\000\002u\002u\002u\002u\000\238\t\246\000\000\000\000\nr\002u\000\238\002u\002u\000\000\002u\002u\002u\002u\002u\002u\022b\000\000\002u\002u\002u\000\000\000\000\br\000\000\002u\002u\002u\002u\002q\tF\019R\000\000\002q\019^\001\254\002q\004\169\002z\002q\tZ\002q\000\000\000\000\002q\000\000\002q\002q\002q\000\000\002q\002q\002q\006N\004\241\000\000\005\250\b\222\002q\002q\002q\002q\002q\006b\002q\000\000\r\017\006j\000\000\000\000\002q\002q\002q\002q\002q\tF\029\226\001\206\000\000\002q\000\000\002q\002q\t\185\000\000\tZ\r\017\002q\002q\002q\018\n\006J\002:\000\000\001\241\001\241\002q\002q\002q\002q\002q\002q\002q\002q\002q\002>\t\238\nj\000\238\002q\002q\002q\014\022\000\000\000\000\000\000\000\000\005\154\002q\002q\002q\000\n\002q\002q\002q\002q\014.\t\246\014:\000\000\nr\002q\000\238\002q\002q\000\000\002q\002q\002q\002q\002q\002q\016b\000\000\002q\002q\002q\0069\000\000\001\241\007^\002q\002q\002q\002q\002e\tm\000\000\000\000\002e\000\000\003\162\002e\tv\002\174\002e\026:\002e\000\000\019f\002e\000\000\002e\002e\002e\000\000\002e\002e\002e\006N\t\229\000\000\005\250\006V\002e\002e\002e\002e\002e\006b\002e\0069\007\218\006j\000\000\000\238\002e\002e\002e\002e\002e\000\000\t\150\001\174\000\000\002e\003\150\002e\002e\021&\000\238\0069\016.\002e\002e\002e\016>\016N\016Z\t\238\nj\000\000\002e\002e\002e\002e\002e\002e\002e\002e\002e\000\000\t\238\nj\000\000\002e\002e\002e\014V\000\000\t\246\000\000\tm\nr\002e\002e\002e\000\000\002e\002e\002e\002e\014z\t\246\014\158\000\000\nr\002e\019j\002e\002e\000\000\002e\002e\002e\002e\002e\002e\015:\r\005\002e\002e\002e\000\000\000\000\000\000\000\000\002e\002e\002e\002e\002\025\015^\000\000\015\130\002\025\000\000\003\162\002\025\r\005\000\000\002\025\002\022\002\025\000\000\002\026\002\025\000\000\002\025\002\025\002\025\000\000\002\025\002\025\002\025\012\213\012\213\000\000\002&\012\213\002\025\002\025\002\025\002\025\002\025\b\169\002\025\000\000\000\000\b\169\000\000\000\000\002\025\002\025\002\025\002\025\002\025\007^\t\150\016\146\000\000\002\025\000\000\002\025\002\025\0022\000\000\000\000\016.\002\025\002\025\002\025\016>\016N\016Z\000\000\t\190\000\238\002\025\002\025\002\025\002\025\002\025\002\025\002\025\002\025\002\025\b\169\000\000\002\025\000\000\002\025\002\025\002\025\000\000\000\000\000\238\000\000\000\000\007\218\002\025\002\025\002\025\000\000\002\025\002\025\002\025\002\025\012\213\b\169\000\000\000\000\0026\002\025\011)\002\025\002\025\000\238\tF\002\025\002\025\002\025\002\025\002\025\000\000\nF\002\025\002\025\tZ\030\175\000\000\007^\007^\002\025\002\025\002\025\002\025\t\157\000\000\000\000\000\000\t\157\000\000\006N\t\157\011)\005\250\t\157\004\218\t\157\019\030\019Z\t\157\006b\t\157\t\157\t\157\006j\t\157\t\157\t\157\011)\000\000\000\000\011)\r\138\t\157\t\157\t\157\t\157\t\157\011)\t\157\007\218\007\218\011)\000\000\000\000\t\157\t\157\t\157\t\157\t\157\002\174\002\230\000\000\002z\t\157\000\000\t\157\t\157\000\238\000\238\000\000\000\000\t\157\t\157\t\157\000\000\027\254\000\000\003\002\000\000\000\000\t\157\t\157\t\157\t\157\t\157\t\157\t\157\t\157\t\157\000\000\003\014\t\157\000\000\t\157\t\157\t\157\000\000\000\000\000\000\000\000\020\162\000\000\t\157\t\157\t\157\000\000\t\157\t\157\t\157\t\157\000\000\000\000\005\138\000\000\018\n\t\157\000\238\t\157\t\157\000\000\tF\t\157\t\157\t\157\t\157\t\157\000\000\000\000\t\157\t\157\tZ\000\000\000\000\005\150\007^\t\157\t\157\t\157\t\157\002m\000\000\005\154\000\000\002m\000\000\003\162\002m\000\000\000\000\002m\000\000\002m\000\000\019\146\002m\000\000\002m\002m\002m\005\158\002m\002m\002m\006N\000\000\000\000\005\250\028\002\002m\002m\002m\002m\002m\006b\002m\000\000\007\218\006j\000\000\000\000\002m\002m\002m\002m\002m\007^\005\210\000\000\000\000\002m\000\000\002m\002m\000\000\000\238\000\000\003\234\002m\002m\002m\006\138\000\000\003\246\000\000\019r\000\000\002m\002m\002m\002m\002m\002m\002m\002m\002m\000\000\000\000\002m\000\000\002m\002m\002m\000\000\000\000\000\000\000\000\000\000\007\218\002m\002m\002m\001\241\002m\002m\002m\002m\000\000\b\185\000\000\000\000\b\185\002m\019\150\002m\002m\000\238\n\134\002m\002m\002m\002m\002m\000\000\000\000\002m\002m\002m\000\n\025b\000\000\007^\002m\002m\002m\002m\t\141\001\241\001\241\019\190\t\141\000\000\002\174\t\141\001\241\000\000\t\141\000\000\t\141\b\185\019\134\t\141\001\241\t\141\t\141\t\141\001\241\t\141\t\141\t\141\001\241\001\241\020\254\b\185\000\n\t\141\t\141\t\141\t\141\t\141\000\000\t\141\000\000\007\218\000\000\001\241\000\000\t\141\t\141\t\141\t\141\t\141\000\000\nv\003\150\000\000\t\141\000\n\t\141\t\141\b\185\000\238\001\241\000\000\t\141\t\141\t\141\r\246\006\134\014\002\000\000\000\000\000\000\t\141\t\141\t\141\t\141\t\141\t\141\t\141\t\141\t\141\000\000\002\174\t\141\001\241\t\141\t\141\t\141\b\185\007\173\000\000\000\000\000\000\007\173\t\141\t\141\t\141\000\000\t\141\t\141\t\141\t\141\000\000\000\000\000\000\000\000\000\000\t\141\000\238\t\141\t\141\000\000\tF\t\141\t\141\t\141\t\141\t\141\000\000\000\000\t\141\t\141\tZ\014\198\003\150\007^\007^\t\141\t\141\t\141\t\141\003\161\000\000\000\000\000\000\003\161\000\000\014\234\003\161\015\014\000\000\003\161\000\000\003\161\019\158\027\246\n\198\000\000\003\161\011\026\003\161\007\173\003\161\003\161\003\161\006N\000\000\000\000\005\250\000\000\011.\011v\011\142\011F\011\166\006b\003\161\007\218\007\218\006j\000\000\000\000\003\161\003\161\011\190\011\214\003\161\007^\tF\000\000\000\000\003\161\000\000\011\238\003\161\000\238\000\238\000\000\tZ\003\161\003\161\000\238\000\000\000\000\000\000\000\000\029\154\000\000\003\161\003\161\n\222\011^\012\006\012\030\012N\003\161\003\161\000\000\000\000\003\161\000\000\003\161\003\161\012f\000\000\000\000\000\000\000\000\000\000\007\218\003\161\003\161\012~\000\000\003\161\003\161\003\161\003\161\000\000\000\000\000\000\000\000\000\000\003\161\000\238\003\161\003\161\000\238\012\222\003\161\012\246\0126\003\161\003\161\000\000\000\000\003\161\012\150\003\161\000\000\000\000\000\000\000\000\003\161\003\161\012\174\012\198\002\205\000\000\000\000\000\000\002\205\000\000\000\000\002\205\r\158\000\000\002\205\000\000\002\205\000\000\000\000\002\205\000\000\002\205\002\205\002\205\000\000\002\205\002\205\002\205\r\166\000\000\000\000\r\174\000\000\002\205\002\205\002\205\002\205\002\205\r\182\002\205\000\000\000\000\r\190\000\000\000\000\002\205\002\205\002\205\002\205\002\205\000\000\000\000\000\000\000\000\002\205\000\000\002\205\002\205\000\000\000\000\000\000\000\000\002\205\002\205\002\205\000\000\000\000\000\000\000\000\000\000\000\000\002\205\002\205\002\205\002\205\002\205\002\205\002\205\002\205\002\205\000\000\000\000\002\205\000\000\002\205\002\205\002\205\000\000\000\000\000\000\000\000\000\000\000\000\002\205\002\205\002\205\000\000\002\205\002\205\002\205\002\205\000\000\000\000\000\000\000\000\000\000\002\205\000\238\002\205\002\205\000\000\tF\002\205\002\205\002\205\002\205\002\205\000\000\000\000\002\205\002\205\tZ\000\000\000\000\000\000\000\000\002\205\002\205\002\205\002\205\002\201\000\000\000\000\000\000\002\201\000\000\000\000\002\201\bU\000\000\002\201\000\000\002\201\000\000\000\000\002\201\000\000\002\201\002\201\002\201\000\000\002\201\002\201\002\201\bU\000\000\000\000\005\250\000\000\002\201\002\201\002\201\002\201\002\201\bU\002\201\000\000\000\000\bU\000\000\000\000\002\201\002\201\002\201\002\201\002\201\000\000\000\000\000\000\000\000\002\201\000\000\002\201\002\201\000\000\000\000\000\000\000\000\002\201\002\201\002\201\000\000\000\000\000\000\000\000\000\000\000\000\002\201\002\201\n\222\002\201\002\201\002\201\002\201\002\201\002\201\000\000\000\000\002\201\000\000\002\201\002\201\002\201\000\000\000\000\000\000\000\000\000\000\000\000\002\201\002\201\002\201\000\000\002\201\002\201\002\201\002\201\000\000\000\000\000\000\000\000\000\000\002\201\bm\002\201\002\201\000\000\002\201\002\201\002\201\002\201\002\201\002\201\000\000\000\000\002\201\002\201\002\201\000\000\000\000\000\000\000\000\002\201\002\201\002\201\002\201\002\157\000\000\000\000\000\000\002\157\000\000\000\000\002\157\bm\000\000\002\157\000\000\002\157\000\000\000\000\002\157\000\000\002\157\002\157\002\157\000\000\002\157\002\157\002\157\bm\000\000\000\000\005\250\000\000\002\157\002\157\002\157\002\157\002\157\bm\002\157\000\000\000\000\bm\000\000\000\000\002\157\002\157\002\157\002\157\002\157\000\000\000\000\000\000\000\000\002\157\000\000\002\157\002\157\000\000\000\000\000\000\000\000\002\157\002\157\002\157\000\000\000\000\000\000\000\000\000\000\000\000\002\157\002\157\002\157\002\157\002\157\002\157\002\157\002\157\002\157\000\000\000\000\002\157\000\000\002\157\002\157\002\157\000\000\000\000\000\000\000\000\000\000\000\000\002\157\002\157\002\157\000\000\002\157\002\157\002\157\002\157\000\000\000\000\000\000\000\000\000\000\002\157\000\238\002\157\002\157\000\000\tF\002\157\002\157\002\157\002\157\002\157\000\000\000\000\002\157\002\157\tZ\000\000\000\000\000\000\000\000\002\157\002\157\002\157\002\157\002\153\000\000\000\000\000\000\002\153\000\000\000\000\002\153\b\129\000\000\002\153\000\000\002\153\000\000\000\000\002\153\000\000\002\153\002\153\002\153\000\000\002\153\002\153\002\153\006N\000\000\000\000\005\250\000\000\002\153\002\153\002\153\002\153\002\153\b\129\002\153\000\000\000\000\b\129\000\000\000\000\002\153\002\153\002\153\002\153\002\153\000\000\000\000\000\000\000\000\002\153\000\000\002\153\002\153\000\000\000\000\000\000\000\000\002\153\002\153\002\153\000\000\000\000\000\000\000\000\000\000\000\000\002\153\002\153\n\222\002\153\002\153\002\153\002\153\002\153\002\153\000\000\000\000\002\153\000\000\002\153\002\153\002\153\000\000\000\000\000\000\000\000\000\000\000\000\002\153\002\153\002\153\000\000\002\153\002\153\002\153\002\153\000\000\000\000\000\000\000\000\000\000\002\153\b}\002\153\002\153\000\000\002\153\002\153\002\153\002\153\002\153\002\153\000\000\000\000\002\153\002\153\002\153\000\000\000\000\000\000\000\000\002\153\002\153\002\153\002\153\002\181\000\000\000\000\000\000\002\181\000\000\000\000\002\181\b}\000\000\002\181\000\000\002\181\000\000\000\000\002\181\000\000\002\181\002\181\002\181\000\000\002\181\002\181\002\181\r\210\000\000\000\000\b}\000\000\002\181\002\181\002\181\002\181\002\181\b}\002\181\000\000\000\000\b}\000\000\000\000\002\181\002\181\002\181\002\181\002\181\000\000\000\000\000\000\000\000\002\181\000\000\002\181\002\181\000\000\000\000\000\000\000\000\002\181\002\181\002\181\000\000\000\000\000\000\000\000\000\000\000\000\002\181\002\181\002\181\002\181\002\181\002\181\002\181\002\181\002\181\000\000\000\000\002\181\000\000\002\181\002\181\002\181\000\000\000\000\000\000\000\000\000\000\000\000\002\181\002\181\002\181\000\000\002\181\002\181\002\181\002\181\000\000\000\000\000\000\000\000\000\000\002\181\000\238\002\181\002\181\000\000\tF\002\181\002\181\002\181\002\181\002\181\000\000\000\000\002\181\002\181\tZ\000\000\000\000\000\000\000\000\002\181\002\181\002\181\002\181\002\177\000\000\000\000\000\000\002\177\000\000\000\000\002\177\bQ\000\000\002\177\000\000\002\177\000\000\000\000\n\198\000\000\002\177\002\177\002\177\000\000\002\177\002\177\002\177\bQ\000\000\000\000\005\250\000\000\002\177\002\177\002\177\011F\002\177\bQ\002\177\000\000\000\000\bQ\000\000\000\000\002\177\002\177\002\177\002\177\002\177\000\000\000\000\000\000\000\000\002\177\000\000\002\177\002\177\000\000\000\000\000\000\000\000\002\177\002\177\002\177\000\000\000\000\000\000\000\000\000\000\000\000\002\177\002\177\n\222\011^\002\177\002\177\002\177\002\177\002\177\000\000\000\000\002\177\000\000\002\177\002\177\002\177\000\000\000\000\000\000\000\000\000\000\000\000\002\177\002\177\002\177\000\000\002\177\002\177\002\177\002\177\000\000\000\000\000\000\000\000\000\000\002\177\000\238\002\177\002\177\000\000\002\177\002\177\002\177\002\177\002\177\002\177\000\000\000\000\002\177\002\177\002\177\000\000\000\000\000\000\000\000\002\177\002\177\002\177\002\177\002\213\000\000\000\000\000\000\002\213\000\000\000\000\002\213\016\002\000\000\002\213\000\000\002\213\000\000\000\000\002\213\000\000\002\213\002\213\002\213\000\000\002\213\002\213\002\213\r\166\000\000\000\000\r\174\000\000\002\213\002\213\002\213\002\213\002\213\r\182\002\213\000\000\000\000\r\190\000\000\000\000\002\213\002\213\002\213\002\213\002\213\000\000\000\000\000\000\000\000\002\213\000\000\002\213\002\213\000\000\000\000\000\000\000\000\002\213\002\213\002\213\012\221\012\221\000\000\000\000\012\221\000\000\002\213\002\213\002\213\002\213\002\213\002\213\002\213\002\213\002\213\000\000\000\000\002\213\000\000\002\213\002\213\002\213\000\000\000\000\000\000\000\000\000\000\000\000\002\213\002\213\002\213\000\000\002\213\002\213\002\213\002\213\000\000\017\250\000\000\000\000\002z\002\213\000\238\002\213\002\213\000\000\tF\002\213\002\213\002\213\002\213\002\213\000\000\000\000\002\213\002\213\tZ\000\000\000\000\000\000\000\000\002\213\002\213\002\213\002\213\002\209\000\000\000\000\000\000\002\209\000\000\000\000\002\209\012\221\000\000\002\209\000\000\002\209\017\254\000\000\002\209\000\000\002\209\002\209\002\209\000\000\002\209\002\209\002\209\012\217\012\217\000\000\018\n\012\217\002\209\002\209\002\209\002\209\002\209\000\000\002\209\000\000\000\000\000\000\000\000\000\000\002\209\002\209\002\209\002\209\002\209\000\000\000\000\000\000\000\000\002\209\000\000\002\209\002\209\005\154\000\000\000\000\000\000\002\209\002\209\002\209\000\000\000\000\000\000\000\000\000\000\000\238\002\209\002\209\n\222\002\209\002\209\002\209\002\209\002\209\002\209\000\000\000\000\002\209\000\000\002\209\002\209\002\209\028>\000\000\000\000\000\000\000\000\000\000\002\209\002\209\002\209\000\000\002\209\002\209\002\209\002\209\012\217\017\250\000\000\000\000\002z\002\209\000\000\002\209\002\209\000\000\002\209\002\209\002\209\002\209\002\209\002\209\000\000\000\000\002\209\002\209\002\209\000\000\000\000\000\000\000\000\002\209\002\209\002\209\002\209\002\149\000\000\000\000\000\000\002\149\000\000\000\000\002\149\000\000\000\000\002\149\000\000\002\149\017\254\000\000\002\149\000\000\002\149\002\149\002\149\000\000\002\149\002\149\002\149\000\000\000\000\000\000\018\n\000\000\002\149\002\149\002\149\002\149\002\149\000\000\002\149\000\000\000\000\000\000\000\000\000\000\002\149\002\149\002\149\002\149\002\149\000\000\000\000\000\000\000\000\002\149\000\000\002\149\002\149\005\154\000\000\000\000\000\000\002\149\002\149\002\149\000\000\000\000\000\000\000\000\000\000\000\000\002\149\002\149\002\149\002\149\002\149\002\149\002\149\002\149\002\149\000\000\000\000\002\149\000\000\002\149\002\149\002\149\024>\000\000\000\000\000\000\000\000\000\000\002\149\002\149\002\149\000\000\002\149\002\149\002\149\002\149\000\000\000\000\000\000\000\000\000\000\002\149\000\000\002\149\002\149\000\000\tF\002\149\002\149\002\149\002\149\002\149\000\000\000\000\002\149\002\149\tZ\000\000\000\000\000\000\000\000\002\149\002\149\002\149\002\149\002\145\000\000\000\000\000\000\002\145\000\000\000\000\002\145\000\000\000\000\002\145\000\000\002\145\000\000\000\000\002\145\000\000\002\145\002\145\002\145\000\000\002\145\002\145\002\145\000\000\000\000\000\000\000\000\000\000\002\145\002\145\002\145\002\145\002\145\000\000\002\145\000\000\000\000\000\000\000\000\000\000\002\145\002\145\002\145\002\145\002\145\000\000\000\000\000\000\000\000\002\145\000\000\002\145\002\145\000\000\000\000\000\000\000\000\002\145\002\145\002\145\000\000\000\000\000\000\000\000\000\000\000\000\002\145\002\145\n\222\002\145\002\145\002\145\002\145\002\145\002\145\000\000\000\000\002\145\000\000\002\145\002\145\002\145\000\000\000\000\000\000\000\000\000\000\000\000\002\145\002\145\002\145\000\000\002\145\002\145\002\145\002\145\000\000\000\000\000\000\000\000\000\000\002\145\000\000\002\145\002\145\000\000\002\145\002\145\002\145\002\145\002\145\002\145\000\000\000\000\002\145\002\145\002\145\000\000\000\000\000\000\000\000\002\145\002\145\002\145\002\145\002\173\000\000\000\000\000\000\002\173\000\000\000\000\002\173\000\000\000\000\002\173\000\000\002\173\000\000\000\000\002\173\000\000\002\173\002\173\002\173\000\000\002\173\002\173\002\173\000\000\000\000\000\000\000\000\000\000\002\173\002\173\002\173\002\173\002\173\000\000\002\173\000\000\000\000\000\000\000\000\000\000\002\173\002\173\002\173\002\173\002\173\000\000\000\000\000\000\000\000\002\173\000\000\002\173\002\173\000\000\000\000\000\000\000\000\002\173\002\173\002\173\000\000\000\000\000\000\000\000\000\000\000\000\002\173\002\173\002\173\002\173\002\173\002\173\002\173\002\173\002\173\000\000\000\000\002\173\000\000\002\173\002\173\002\173\000\000\000\000\000\000\000\000\000\000\000\000\002\173\002\173\002\173\000\000\002\173\002\173\002\173\002\173\000\000\000\000\000\000\000\000\000\000\002\173\000\000\002\173\002\173\000\000\tF\002\173\002\173\002\173\002\173\002\173\000\000\000\000\002\173\002\173\tZ\000\000\000\000\000\000\000\000\002\173\002\173\002\173\002\173\002\169\000\000\000\000\000\000\002\169\000\000\000\000\002\169\000\000\000\000\002\169\000\000\002\169\000\000\000\000\n\198\000\000\002\169\002\169\002\169\000\000\002\169\002\169\002\169\000\000\000\000\000\000\000\000\000\000\002\169\002\169\002\169\011F\002\169\000\000\002\169\000\000\000\000\000\000\000\000\000\000\002\169\002\169\002\169\002\169\002\169\000\000\000\000\000\000\000\000\002\169\000\000\002\169\002\169\000\000\000\000\000\000\000\000\002\169\002\169\002\169\000\000\000\000\000\000\000\000\000\000\000\000\002\169\002\169\n\222\011^\002\169\002\169\002\169\002\169\002\169\000\000\000\000\002\169\000\000\002\169\002\169\002\169\000\000\000\000\000\000\000\000\000\000\000\000\002\169\002\169\002\169\000\000\002\169\002\169\002\169\002\169\000\000\000\000\000\000\000\000\000\000\002\169\000\000\002\169\002\169\000\000\002\169\002\169\002\169\002\169\002\169\002\169\000\000\000\000\002\169\002\169\002\169\000\000\000\000\000\000\000\000\002\169\002\169\002\169\002\169\002\165\000\000\000\000\000\000\002\165\000\000\000\000\002\165\000\000\000\000\002\165\000\000\002\165\000\000\000\000\002\165\000\000\002\165\002\165\002\165\000\000\002\165\002\165\002\165\000\000\000\000\000\000\000\000\000\000\002\165\002\165\002\165\002\165\002\165\000\000\002\165\000\000\000\000\000\000\000\000\000\000\002\165\002\165\002\165\002\165\002\165\000\000\000\000\000\000\000\000\002\165\000\000\002\165\002\165\000\000\000\000\000\000\000\000\002\165\002\165\002\165\000\000\000\000\000\000\000\000\000\000\000\000\002\165\002\165\002\165\002\165\002\165\002\165\002\165\002\165\002\165\000\000\000\000\002\165\000\000\002\165\002\165\002\165\000\000\000\000\000\000\000\000\000\000\000\000\002\165\002\165\002\165\000\000\002\165\002\165\002\165\002\165\000\000\000\000\000\000\000\000\000\000\002\165\000\000\002\165\002\165\000\000\tF\002\165\002\165\002\165\002\165\002\165\000\000\000\000\002\165\002\165\tZ\000\000\000\000\000\000\000\000\002\165\002\165\002\165\002\165\002\161\000\000\000\000\000\000\002\161\000\000\000\000\002\161\000\000\000\000\002\161\000\000\002\161\000\000\000\000\n\198\000\000\002\161\002\161\002\161\000\000\002\161\002\161\002\161\000\000\000\000\000\000\000\000\000\000\002\161\002\161\002\161\011F\002\161\000\000\002\161\000\000\000\000\000\000\000\000\000\000\002\161\002\161\002\161\002\161\002\161\000\000\000\000\000\000\000\000\002\161\000\000\002\161\002\161\000\000\000\000\000\000\000\000\002\161\002\161\002\161\000\000\000\000\000\000\000\000\000\000\000\000\002\161\002\161\n\222\011^\002\161\002\161\002\161\002\161\002\161\000\000\000\000\002\161\000\000\002\161\002\161\002\161\000\000\000\000\000\000\000\000\000\000\000\000\002\161\002\161\002\161\000\000\002\161\002\161\002\161\002\161\000\000\000\000\000\000\000\000\000\000\002\161\000\000\002\161\002\161\000\000\002\161\002\161\002\161\002\161\002\161\002\161\000\000\000\000\002\161\002\161\002\161\000\000\000\000\000\000\000\000\002\161\002\161\002\161\002\161\002\245\000\000\000\000\000\000\002\245\000\000\000\000\002\245\000\000\000\000\002\245\000\000\002\245\000\000\000\000\002\245\000\000\002\245\002\245\002\245\000\000\002\245\002\245\002\245\000\000\000\000\000\000\000\000\000\000\002\245\002\245\002\245\002\245\002\245\000\000\002\245\000\000\000\000\000\000\000\000\000\000\002\245\002\245\002\245\002\245\002\245\000\000\000\000\000\000\000\000\002\245\000\000\002\245\002\245\000\000\000\000\000\000\000\000\002\245\002\245\002\245\000\000\000\000\000\000\000\000\000\000\000\000\002\245\002\245\002\245\002\245\002\245\002\245\002\245\002\245\002\245\000\000\000\000\002\245\000\000\002\245\002\245\002\245\000\000\000\000\000\000\000\000\000\000\000\000\002\245\002\245\002\245\000\000\002\245\002\245\002\245\002\245\000\000\000\000\000\000\000\000\000\000\002\245\000\000\002\245\002\245\000\000\tF\002\245\002\245\002\245\002\245\002\245\000\000\000\000\002\245\002\245\tZ\000\000\000\000\000\000\000\000\002\245\002\245\002\245\002\245\002\241\000\000\000\000\000\000\002\241\000\000\000\000\002\241\000\000\000\000\002\241\000\000\002\241\000\000\000\000\n\198\000\000\002\241\002\241\002\241\000\000\002\241\002\241\002\241\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\002\241\000\000\000\000\000\000\000\000\000\000\002\241\002\241\011\190\011\214\002\241\000\000\000\000\000\000\000\000\002\241\000\000\011\238\002\241\000\000\000\000\000\000\000\000\002\241\002\241\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\241\002\241\n\222\011^\012\006\012\030\012N\002\241\002\241\000\000\000\000\002\241\000\000\002\241\002\241\012f\000\000\000\000\000\000\000\000\000\000\000\000\002\241\002\241\012~\000\000\002\241\002\241\002\241\002\241\000\000\000\000\000\000\000\000\000\000\002\241\000\000\002\241\002\241\000\000\002\241\002\241\002\241\0126\002\241\002\241\000\000\000\000\002\241\012\150\002\241\000\000\000\000\000\000\000\000\002\241\002\241\012\174\012\198\002\197\000\000\000\000\000\000\002\197\000\000\000\000\002\197\000\000\000\000\002\197\000\000\002\197\000\000\000\000\002\197\000\000\002\197\002\197\002\197\000\000\002\197\002\197\002\197\000\000\000\000\000\000\000\000\000\000\002\197\002\197\002\197\002\197\002\197\000\000\002\197\000\000\000\000\000\000\000\000\000\000\002\197\002\197\002\197\002\197\002\197\000\000\000\000\000\000\000\000\002\197\000\000\002\197\002\197\000\000\000\000\000\000\000\000\002\197\002\197\002\197\000\000\000\000\000\000\000\000\000\000\000\000\002\197\002\197\002\197\002\197\002\197\002\197\002\197\002\197\002\197\000\000\000\000\002\197\000\000\002\197\002\197\002\197\000\000\000\000\000\000\000\000\000\000\000\000\002\197\002\197\002\197\000\000\002\197\002\197\002\197\002\197\000\000\000\000\000\000\000\000\000\000\002\197\000\000\002\197\002\197\000\000\tF\002\197\002\197\002\197\002\197\002\197\000\000\000\000\002\197\002\197\tZ\000\000\000\000\000\000\000\000\002\197\002\197\002\197\002\197\002\193\000\000\000\000\000\000\002\193\000\000\000\000\002\193\000\000\000\000\002\193\000\000\002\193\000\000\000\000\n\198\000\000\002\193\002\193\002\193\000\000\002\193\002\193\002\193\000\000\000\000\000\000\000\000\000\000\002\193\002\193\002\193\011F\002\193\000\000\002\193\000\000\000\000\000\000\000\000\000\000\002\193\002\193\002\193\002\193\002\193\000\000\000\000\000\000\000\000\002\193\000\000\002\193\002\193\000\000\000\000\000\000\000\000\002\193\002\193\002\193\000\000\000\000\000\000\000\000\000\000\000\000\002\193\002\193\n\222\011^\002\193\002\193\002\193\002\193\002\193\000\000\000\000\002\193\000\000\002\193\002\193\002\193\000\000\000\000\000\000\000\000\000\000\000\000\002\193\002\193\002\193\000\000\002\193\002\193\002\193\002\193\000\000\000\000\000\000\000\000\000\000\002\193\000\000\002\193\002\193\000\000\002\193\002\193\002\193\002\193\002\193\002\193\000\000\000\000\002\193\002\193\002\193\000\000\000\000\000\000\000\000\002\193\002\193\002\193\002\193\002\189\000\000\000\000\000\000\002\189\000\000\000\000\002\189\000\000\000\000\002\189\000\000\002\189\000\000\000\000\002\189\000\000\002\189\002\189\002\189\000\000\002\189\002\189\002\189\000\000\000\000\000\000\000\000\000\000\002\189\002\189\002\189\002\189\002\189\000\000\002\189\000\000\000\000\000\000\000\000\000\000\002\189\002\189\002\189\002\189\002\189\000\000\000\000\000\000\000\000\002\189\000\000\002\189\002\189\000\000\000\000\000\000\000\000\002\189\002\189\002\189\000\000\000\000\000\000\000\000\000\000\000\000\002\189\002\189\002\189\002\189\002\189\002\189\002\189\002\189\002\189\000\000\000\000\002\189\000\000\002\189\002\189\002\189\000\000\000\000\000\000\000\000\000\000\000\000\002\189\002\189\002\189\000\000\002\189\002\189\002\189\002\189\000\000\000\000\000\000\000\000\000\000\002\189\000\000\002\189\002\189\000\000\tF\002\189\002\189\002\189\002\189\002\189\000\000\000\000\002\189\002\189\tZ\000\000\000\000\000\000\000\000\002\189\002\189\002\189\002\189\002\185\000\000\000\000\000\000\002\185\000\000\000\000\002\185\000\000\000\000\002\185\000\000\002\185\000\000\000\000\n\198\000\000\002\185\002\185\002\185\000\000\002\185\002\185\002\185\000\000\000\000\000\000\000\000\000\000\002\185\002\185\002\185\011F\002\185\000\000\002\185\000\000\000\000\000\000\000\000\000\000\002\185\002\185\002\185\002\185\002\185\000\000\000\000\000\000\000\000\002\185\000\000\002\185\002\185\000\000\000\000\000\000\000\000\002\185\002\185\002\185\000\000\000\000\000\000\000\000\000\000\000\000\002\185\002\185\n\222\011^\002\185\002\185\002\185\002\185\002\185\000\000\000\000\002\185\000\000\002\185\002\185\002\185\000\000\000\000\000\000\000\000\000\000\000\000\002\185\002\185\002\185\000\000\002\185\002\185\002\185\002\185\000\000\000\000\000\000\000\000\000\000\002\185\000\000\002\185\002\185\000\000\002\185\002\185\002\185\002\185\002\185\002\185\000\000\000\000\002\185\002\185\002\185\000\000\000\000\000\000\000\000\002\185\002\185\002\185\002\185\002\229\000\000\000\000\000\000\002\229\000\000\000\000\002\229\000\000\000\000\002\229\000\000\002\229\000\000\000\000\002\229\000\000\002\229\002\229\002\229\000\000\002\229\002\229\002\229\000\000\000\000\000\000\000\000\000\000\002\229\002\229\002\229\002\229\002\229\000\000\002\229\000\000\000\000\000\000\000\000\000\000\002\229\002\229\002\229\002\229\002\229\000\000\000\000\000\000\000\000\002\229\000\000\002\229\002\229\000\000\000\000\000\000\000\000\002\229\002\229\002\229\000\000\000\000\000\000\000\000\000\000\000\000\002\229\002\229\002\229\002\229\002\229\002\229\002\229\002\229\002\229\000\000\000\000\002\229\000\000\002\229\002\229\002\229\000\000\000\000\000\000\000\000\000\000\000\000\002\229\002\229\002\229\000\000\002\229\002\229\002\229\002\229\000\000\000\000\000\000\000\000\000\000\002\229\000\000\002\229\002\229\000\000\tF\002\229\002\229\002\229\002\229\002\229\000\000\000\000\002\229\002\229\tZ\000\000\000\000\000\000\000\000\002\229\002\229\002\229\002\229\002\225\000\000\000\000\000\000\002\225\000\000\000\000\002\225\000\000\000\000\002\225\000\000\002\225\000\000\000\000\n\198\000\000\002\225\002\225\002\225\000\000\002\225\002\225\002\225\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\002\225\000\000\002\225\000\000\000\000\000\000\000\000\000\000\002\225\002\225\011\190\011\214\002\225\000\000\000\000\000\000\000\000\002\225\000\000\002\225\002\225\000\000\000\000\000\000\000\000\002\225\002\225\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\225\002\225\n\222\011^\012\006\012\030\002\225\002\225\002\225\000\000\000\000\002\225\000\000\002\225\002\225\002\225\000\000\000\000\000\000\000\000\000\000\000\000\002\225\002\225\002\225\000\000\002\225\002\225\002\225\002\225\000\000\000\000\000\000\000\000\000\000\002\225\000\000\002\225\002\225\000\000\002\225\002\225\002\225\0126\002\225\002\225\000\000\000\000\002\225\002\225\002\225\000\000\000\000\000\000\000\000\002\225\002\225\002\225\002\225\002\141\000\000\000\000\000\000\002\141\000\000\000\000\002\141\000\000\000\000\002\141\000\000\002\141\000\000\000\000\002\141\000\000\002\141\002\141\002\141\000\000\002\141\002\141\002\141\000\000\000\000\000\000\000\000\000\000\002\141\002\141\002\141\002\141\002\141\000\000\002\141\000\000\000\000\000\000\000\000\000\000\002\141\002\141\002\141\002\141\002\141\000\000\000\000\000\000\000\000\002\141\000\000\002\141\002\141\000\000\000\000\000\000\000\000\002\141\002\141\002\141\000\000\000\000\000\000\000\000\000\000\000\000\002\141\002\141\002\141\002\141\002\141\002\141\002\141\002\141\002\141\000\000\000\000\002\141\000\000\002\141\002\141\002\141\000\000\000\000\000\000\000\000\000\000\000\000\002\141\002\141\002\141\000\000\002\141\002\141\002\141\002\141\000\000\000\000\000\000\000\000\000\000\002\141\000\000\002\141\002\141\000\000\tF\002\141\002\141\002\141\002\141\002\141\000\000\000\000\002\141\002\141\tZ\000\000\000\000\000\000\000\000\002\141\002\141\002\141\002\141\002\137\000\000\000\000\000\000\002\137\000\000\000\000\002\137\000\000\000\000\002\137\000\000\002\137\000\000\000\000\n\198\000\000\002\137\002\137\002\137\000\000\002\137\002\137\002\137\000\000\000\000\000\000\000\000\000\000\002\137\002\137\002\137\011F\002\137\000\000\002\137\000\000\000\000\000\000\000\000\000\000\002\137\002\137\002\137\002\137\002\137\000\000\000\000\000\000\000\000\002\137\000\000\002\137\002\137\000\000\000\000\000\000\000\000\002\137\002\137\002\137\000\000\000\000\000\000\000\000\000\000\000\000\002\137\002\137\n\222\011^\002\137\002\137\002\137\002\137\002\137\000\000\000\000\002\137\000\000\002\137\002\137\002\137\000\000\000\000\000\000\000\000\000\000\000\000\002\137\002\137\002\137\000\000\002\137\002\137\002\137\002\137\000\000\000\000\000\000\000\000\000\000\002\137\000\000\002\137\002\137\000\000\002\137\002\137\002\137\002\137\002\137\002\137\000\000\000\000\002\137\002\137\002\137\000\000\000\000\000\000\000\000\002\137\002\137\002\137\002\137\002\133\000\000\000\000\000\000\002\133\000\000\000\000\002\133\000\000\000\000\002\133\000\000\002\133\000\000\000\000\002\133\000\000\002\133\002\133\002\133\000\000\002\133\002\133\002\133\000\000\000\000\000\000\000\000\000\000\002\133\002\133\002\133\002\133\002\133\000\000\002\133\000\000\000\000\000\000\000\000\000\000\002\133\002\133\002\133\002\133\002\133\000\000\000\000\000\000\000\000\002\133\000\000\002\133\002\133\000\000\000\000\000\000\000\000\002\133\002\133\002\133\000\000\000\000\000\000\000\000\000\000\000\000\002\133\002\133\002\133\002\133\002\133\002\133\002\133\002\133\002\133\000\000\000\000\002\133\000\000\002\133\002\133\002\133\000\000\000\000\000\000\000\000\000\000\000\000\002\133\002\133\002\133\000\000\002\133\002\133\002\133\002\133\000\000\000\000\000\000\000\000\000\000\002\133\000\000\002\133\002\133\000\000\tF\002\133\002\133\002\133\002\133\002\133\000\000\000\000\002\133\002\133\tZ\000\000\000\000\000\000\000\000\002\133\002\133\002\133\002\133\002\129\000\000\000\000\000\000\002\129\000\000\000\000\002\129\000\000\000\000\002\129\000\000\002\129\000\000\000\000\n\198\000\000\002\129\002\129\002\129\000\000\002\129\002\129\002\129\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\002\129\000\000\002\129\000\000\000\000\000\000\000\000\000\000\002\129\002\129\011\190\011\214\002\129\000\000\000\000\000\000\000\000\002\129\000\000\002\129\002\129\000\000\000\000\000\000\000\000\002\129\002\129\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\129\002\129\n\222\011^\012\006\012\030\002\129\002\129\002\129\000\000\000\000\002\129\000\000\002\129\002\129\002\129\000\000\000\000\000\000\000\000\000\000\000\000\002\129\002\129\002\129\000\000\002\129\002\129\002\129\002\129\000\000\000\000\000\000\000\000\000\000\002\129\000\000\002\129\002\129\000\000\002\129\002\129\002\129\0126\002\129\002\129\000\000\000\000\002\129\002\129\002\129\000\000\000\000\000\000\000\000\002\129\002\129\002\129\002\129\0035\000\000\000\000\000\000\0035\000\000\000\000\0035\000\000\000\000\0035\000\000\0035\000\000\000\000\0035\000\000\0035\0035\0035\000\000\0035\0035\0035\000\000\000\000\000\000\000\000\000\000\0035\0035\0035\0035\0035\000\000\0035\000\000\000\000\000\000\000\000\000\000\0035\0035\0035\0035\0035\000\000\000\000\000\000\000\000\0035\000\000\0035\0035\000\000\000\000\000\000\000\000\0035\0035\0035\000\000\000\000\000\000\000\000\000\000\000\000\0035\0035\0035\0035\0035\0035\0035\0035\0035\000\000\000\000\0035\000\000\0035\0035\0035\000\000\000\000\000\000\000\000\000\000\000\000\0035\0035\0035\000\000\0035\0035\0035\0035\000\000\000\000\000\000\000\000\000\000\0035\000\000\0035\0035\000\000\tF\0035\0035\0035\0035\0035\000\000\000\000\0035\0035\tZ\000\000\000\000\000\000\000\000\0035\0035\0035\0035\0031\000\000\000\000\000\000\0031\000\000\000\000\0031\000\000\000\000\0031\000\000\0031\000\000\000\000\n\198\000\000\0031\0031\0031\000\000\0031\0031\0031\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\0031\000\000\0031\000\000\000\000\000\000\000\000\000\000\0031\0031\011\190\011\214\0031\000\000\000\000\000\000\000\000\0031\000\000\0031\0031\000\000\000\000\000\000\000\000\0031\0031\0031\000\000\000\000\000\000\000\000\000\000\000\000\0031\0031\n\222\011^\012\006\0031\0031\0031\0031\000\000\000\000\0031\000\000\0031\0031\0031\000\000\000\000\000\000\000\000\000\000\000\000\0031\0031\0031\000\000\0031\0031\0031\0031\000\000\000\000\000\000\000\000\000\000\0031\000\000\0031\0031\000\000\0031\0031\0031\0126\0031\0031\000\000\000\000\0031\0031\0031\000\000\000\000\000\000\000\000\0031\0031\0031\0031\002}\000\000\000\000\000\000\002}\000\000\000\000\002}\000\000\000\000\002}\000\000\002}\000\000\000\000\002}\000\000\002}\002}\002}\000\000\002}\002}\002}\000\000\000\000\000\000\000\000\000\000\002}\002}\002}\002}\002}\000\000\002}\000\000\000\000\000\000\000\000\000\000\002}\002}\002}\002}\002}\000\000\000\000\000\000\000\000\002}\000\000\002}\002}\000\000\000\000\000\000\000\000\002}\002}\002}\000\000\000\000\000\000\000\000\000\000\000\000\002}\002}\002}\002}\002}\002}\002}\002}\002}\000\000\000\000\002}\000\000\002}\002}\002}\000\000\000\000\000\000\000\000\000\000\000\000\002}\002}\002}\000\000\002}\002}\002}\002}\000\000\000\000\000\000\000\000\000\000\002}\000\000\002}\002}\000\000\tF\002}\002}\002}\002}\002}\000\000\000\000\002}\002}\tZ\000\000\000\000\000\000\000\000\002}\002}\002}\002}\002y\000\000\000\000\000\000\002y\000\000\000\000\002y\000\000\000\000\002y\000\000\002y\000\000\000\000\n\198\000\000\002y\002y\002y\000\000\002y\002y\002y\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\002y\000\000\002y\000\000\000\000\000\000\000\000\000\000\002y\002y\011\190\011\214\002y\000\000\000\000\000\000\000\000\002y\000\000\002y\002y\000\000\000\000\000\000\000\000\002y\002y\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002y\002y\n\222\011^\012\006\012\030\002y\002y\002y\000\000\000\000\002y\000\000\002y\002y\002y\000\000\000\000\000\000\000\000\000\000\000\000\002y\002y\002y\000\000\002y\002y\002y\002y\000\000\000\000\000\000\000\000\000\000\002y\000\000\002y\002y\000\000\002y\002y\002y\0126\002y\002y\000\000\000\000\002y\002y\002y\000\000\000\000\000\000\000\000\002y\002y\002y\002y\002\237\000\000\000\000\000\000\002\237\000\000\000\000\002\237\000\000\000\000\002\237\000\000\002\237\000\000\000\000\002\237\000\000\002\237\002\237\002\237\000\000\002\237\002\237\002\237\000\000\000\000\000\000\000\000\000\000\002\237\002\237\002\237\002\237\002\237\000\000\002\237\000\000\000\000\000\000\000\000\000\000\002\237\002\237\002\237\002\237\002\237\000\000\000\000\000\000\000\000\002\237\000\000\002\237\002\237\000\000\000\000\000\000\000\000\002\237\002\237\002\237\000\000\000\000\000\000\000\000\000\000\000\000\002\237\002\237\002\237\002\237\002\237\002\237\002\237\002\237\002\237\000\000\000\000\002\237\000\000\002\237\002\237\002\237\000\000\000\000\000\000\000\000\000\000\000\000\002\237\002\237\002\237\000\000\002\237\002\237\002\237\002\237\000\000\000\000\000\000\000\000\000\000\002\237\000\000\002\237\002\237\000\000\tF\002\237\002\237\002\237\002\237\002\237\000\000\000\000\002\237\002\237\tZ\000\000\000\000\000\000\000\000\002\237\002\237\002\237\002\237\002\233\000\000\000\000\000\000\002\233\000\000\000\000\002\233\000\000\000\000\002\233\000\000\002\233\000\000\000\000\n\198\000\000\002\233\002\233\002\233\000\000\002\233\002\233\002\233\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\002\233\000\000\002\233\000\000\000\000\000\000\000\000\000\000\002\233\002\233\011\190\011\214\002\233\000\000\000\000\000\000\000\000\002\233\000\000\002\233\002\233\000\000\000\000\000\000\000\000\002\233\002\233\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\233\002\233\n\222\011^\012\006\012\030\002\233\002\233\002\233\000\000\000\000\002\233\000\000\002\233\002\233\002\233\000\000\000\000\000\000\000\000\000\000\000\000\002\233\002\233\002\233\000\000\002\233\002\233\002\233\002\233\000\000\000\000\000\000\000\000\000\000\002\233\000\000\002\233\002\233\000\000\002\233\002\233\002\233\0126\002\233\002\233\000\000\000\000\002\233\002\233\002\233\000\000\000\000\000\000\000\000\002\233\002\233\002\233\002\233\002\221\000\000\000\000\000\000\002\221\000\000\000\000\002\221\000\000\000\000\002\221\000\000\002\221\000\000\000\000\002\221\000\000\002\221\002\221\002\221\000\000\002\221\002\221\002\221\000\000\000\000\000\000\000\000\000\000\002\221\002\221\002\221\002\221\002\221\000\000\002\221\000\000\000\000\000\000\000\000\000\000\002\221\002\221\002\221\002\221\002\221\000\000\000\000\000\000\000\000\002\221\000\000\002\221\002\221\000\000\000\000\000\000\000\000\002\221\002\221\002\221\000\000\000\000\000\000\000\000\000\000\000\000\002\221\002\221\002\221\002\221\002\221\002\221\002\221\002\221\002\221\000\000\000\000\002\221\000\000\002\221\002\221\002\221\000\000\000\000\000\000\000\000\000\000\000\000\002\221\002\221\002\221\000\000\002\221\002\221\002\221\002\221\000\000\000\000\000\000\000\000\000\000\002\221\000\000\002\221\002\221\000\000\tF\002\221\002\221\002\221\002\221\002\221\000\000\000\000\002\221\002\221\tZ\000\000\000\000\000\000\000\000\002\221\002\221\002\221\002\221\002\217\000\000\000\000\000\000\002\217\000\000\000\000\002\217\000\000\000\000\002\217\000\000\002\217\000\000\000\000\n\198\000\000\002\217\002\217\002\217\000\000\002\217\002\217\002\217\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\002\217\000\000\002\217\000\000\000\000\000\000\000\000\000\000\002\217\002\217\011\190\011\214\002\217\000\000\000\000\000\000\000\000\002\217\000\000\002\217\002\217\000\000\000\000\000\000\000\000\002\217\002\217\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\217\002\217\n\222\011^\012\006\012\030\002\217\002\217\002\217\000\000\000\000\002\217\000\000\002\217\002\217\002\217\000\000\000\000\000\000\000\000\000\000\000\000\002\217\002\217\002\217\000\000\002\217\002\217\002\217\002\217\000\000\000\000\000\000\000\000\000\000\002\217\000\000\002\217\002\217\000\000\002\217\002\217\002\217\0126\002\217\002\217\000\000\000\000\002\217\002\217\002\217\000\000\000\000\000\000\000\000\002\217\002\217\002\217\002\217\002\253\000\000\000\000\000\000\002\253\000\000\000\000\002\253\000\000\000\000\002\253\000\000\002\253\000\000\000\000\002\253\000\000\002\253\002\253\002\253\000\000\002\253\002\253\002\253\000\000\000\000\000\000\000\000\000\000\002\253\002\253\002\253\002\253\002\253\000\000\002\253\000\000\000\000\000\000\000\000\000\000\002\253\002\253\002\253\002\253\002\253\000\000\000\000\000\000\000\000\002\253\000\000\002\253\002\253\000\000\000\000\000\000\000\000\002\253\002\253\002\253\000\000\000\000\000\000\000\000\000\000\000\000\002\253\002\253\002\253\002\253\002\253\002\253\002\253\002\253\002\253\000\000\000\000\002\253\000\000\002\253\002\253\002\253\000\000\000\000\000\000\000\000\000\000\000\000\002\253\002\253\002\253\000\000\002\253\002\253\002\253\002\253\000\000\000\000\000\000\000\000\000\000\002\253\000\000\002\253\002\253\000\000\tF\002\253\002\253\002\253\002\253\002\253\000\000\000\000\002\253\002\253\tZ\000\000\000\000\000\000\000\000\002\253\002\253\002\253\002\253\002\249\000\000\000\000\000\000\002\249\000\000\000\000\002\249\000\000\000\000\002\249\000\000\002\249\000\000\000\000\n\198\000\000\002\249\002\249\002\249\000\000\002\249\002\249\002\249\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\002\249\000\000\000\000\000\000\000\000\000\000\002\249\002\249\011\190\011\214\002\249\000\000\000\000\000\000\000\000\002\249\000\000\011\238\002\249\000\000\000\000\000\000\000\000\002\249\002\249\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002\249\002\249\n\222\011^\012\006\012\030\012N\002\249\002\249\000\000\000\000\002\249\000\000\002\249\002\249\012f\000\000\000\000\000\000\000\000\000\000\000\000\002\249\002\249\012~\000\000\002\249\002\249\002\249\002\249\000\000\000\000\000\000\000\000\000\000\002\249\000\000\002\249\002\249\000\000\002\249\002\249\002\249\0126\002\249\002\249\000\000\000\000\002\249\012\150\002\249\000\000\000\000\000\000\000\000\002\249\002\249\012\174\012\198\003\005\000\000\000\000\000\000\003\005\000\000\000\000\003\005\000\000\000\000\003\005\000\000\003\005\000\000\000\000\003\005\000\000\003\005\003\005\003\005\000\000\003\005\003\005\003\005\000\000\000\000\000\000\000\000\000\000\003\005\003\005\003\005\003\005\003\005\000\000\003\005\000\000\000\000\000\000\000\000\000\000\003\005\003\005\003\005\003\005\003\005\000\000\000\000\000\000\000\000\003\005\000\000\003\005\003\005\000\000\000\000\000\000\000\000\003\005\003\005\003\005\000\000\000\000\000\000\000\000\000\000\000\000\003\005\003\005\003\005\003\005\003\005\003\005\003\005\003\005\003\005\000\000\000\000\003\005\000\000\003\005\003\005\003\005\000\000\000\000\000\000\000\000\000\000\000\000\003\005\003\005\003\005\000\000\003\005\003\005\003\005\003\005\000\000\000\000\000\000\000\000\000\000\003\005\000\000\003\005\003\005\000\000\tF\003\005\003\005\003\005\003\005\003\005\000\000\000\000\003\005\003\005\tZ\000\000\000\000\000\000\000\000\003\005\003\005\003\005\003\005\003\001\000\000\000\000\000\000\003\001\000\000\000\000\003\001\000\000\000\000\003\001\000\000\003\001\000\000\000\000\n\198\000\000\003\001\003\001\003\001\000\000\003\001\003\001\003\001\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\003\001\000\000\003\001\000\000\000\000\000\000\000\000\000\000\003\001\003\001\011\190\011\214\003\001\000\000\000\000\000\000\000\000\003\001\000\000\011\238\003\001\000\000\000\000\000\000\000\000\003\001\003\001\000\238\000\000\000\000\000\000\000\000\000\000\000\000\003\001\003\001\n\222\011^\012\006\012\030\012N\003\001\003\001\000\000\000\000\003\001\000\000\003\001\003\001\012f\000\000\000\000\000\000\000\000\000\000\000\000\003\001\003\001\012~\000\000\003\001\003\001\003\001\003\001\000\000\000\000\000\000\000\000\000\000\003\001\000\000\003\001\003\001\000\000\003\001\003\001\003\001\0126\003\001\003\001\000\000\000\000\003\001\003\001\003\001\000\000\000\000\000\000\000\000\003\001\003\001\012\174\012\198\003\r\000\000\000\000\000\000\003\r\000\000\000\000\003\r\000\000\000\000\003\r\000\000\003\r\000\000\000\000\003\r\000\000\003\r\003\r\003\r\000\000\003\r\003\r\003\r\000\000\000\000\000\000\000\000\000\000\003\r\003\r\003\r\003\r\003\r\000\000\003\r\000\000\000\000\000\000\000\000\000\000\003\r\003\r\003\r\003\r\003\r\000\000\000\000\000\000\000\000\003\r\000\000\003\r\003\r\000\000\000\000\000\000\000\000\003\r\003\r\003\r\000\000\000\000\000\000\000\000\000\000\000\000\003\r\003\r\003\r\003\r\003\r\003\r\003\r\003\r\003\r\000\000\000\000\003\r\000\000\003\r\003\r\003\r\000\000\000\000\000\000\000\000\000\000\000\000\003\r\003\r\003\r\000\000\003\r\003\r\003\r\003\r\000\000\000\000\000\000\000\000\000\000\003\r\000\000\003\r\003\r\000\000\tF\003\r\003\r\003\r\003\r\003\r\000\000\000\000\003\r\003\r\tZ\000\000\000\000\000\000\000\000\003\r\003\r\003\r\003\r\003\t\000\000\000\000\000\000\003\t\000\000\000\000\003\t\000\000\000\000\003\t\000\000\003\t\000\000\000\000\n\198\000\000\003\t\003\t\003\t\000\000\003\t\003\t\003\t\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\003\t\000\000\003\t\000\000\000\000\000\000\000\000\000\000\003\t\003\t\011\190\011\214\003\t\000\000\000\000\000\000\000\000\003\t\000\000\011\238\003\t\000\000\000\000\000\000\000\000\003\t\003\t\000\238\000\000\000\000\000\000\000\000\000\000\000\000\003\t\003\t\n\222\011^\012\006\012\030\012N\003\t\003\t\000\000\000\000\003\t\000\000\003\t\003\t\012f\000\000\000\000\000\000\000\000\000\000\000\000\003\t\003\t\012~\000\000\003\t\003\t\003\t\003\t\000\000\000\000\000\000\000\000\000\000\003\t\000\000\003\t\003\t\000\000\003\t\003\t\003\t\0126\003\t\003\t\000\000\000\000\003\t\003\t\003\t\000\000\000\000\000\000\000\000\003\t\003\t\012\174\012\198\t\149\000\000\000\000\000\000\t\149\000\000\000\000\t\149\000\000\000\000\t\149\000\000\t\149\000\000\000\000\t\149\000\000\t\149\t\149\t\149\000\000\t\149\t\149\t\149\000\000\000\000\000\000\000\000\000\000\t\149\t\149\t\149\t\149\t\149\000\000\t\149\000\000\000\000\000\000\000\000\000\000\t\149\t\149\t\149\t\149\t\149\000\000\000\000\000\000\000\000\t\149\000\000\t\149\t\149\000\000\000\000\000\000\000\000\t\149\t\149\t\149\000\000\000\000\000\000\000\000\000\000\000\000\t\149\t\149\t\149\t\149\t\149\t\149\t\149\t\149\t\149\000\000\000\000\t\149\000\000\t\149\t\149\t\149\000\000\000\000\000\000\000\000\000\000\000\000\t\149\t\149\t\149\000\000\t\149\t\149\t\149\t\149\000\000\000\000\000\000\000\000\000\000\t\149\000\000\t\149\t\149\000\000\tF\t\149\t\149\t\149\t\149\t\149\000\000\000\000\t\149\t\149\tZ\000\000\000\000\000\000\000\000\t\149\t\149\t\149\t\149\t\145\000\000\000\000\000\000\t\145\000\000\000\000\t\145\000\000\000\000\t\145\000\000\t\145\000\000\000\000\n\198\000\000\t\145\t\145\t\145\000\000\t\145\t\145\t\145\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\t\145\000\000\000\000\000\000\000\000\000\000\t\145\t\145\011\190\011\214\t\145\000\000\000\000\000\000\000\000\t\145\000\000\011\238\t\145\000\000\000\000\000\000\000\000\t\145\t\145\000\238\000\000\000\000\000\000\000\000\000\000\000\000\t\145\t\145\n\222\011^\012\006\012\030\012N\t\145\t\145\000\000\000\000\t\145\000\000\t\145\t\145\012f\000\000\000\000\000\000\000\000\000\000\000\000\t\145\t\145\012~\000\000\t\145\t\145\t\145\t\145\000\000\000\000\000\000\000\000\000\000\t\145\000\000\t\145\t\145\000\000\t\145\t\145\t\145\0126\t\145\t\145\000\000\000\000\t\145\012\150\t\145\000\000\000\000\000\000\000\000\t\145\t\145\012\174\012\198\003\021\000\000\000\000\000\000\003\021\000\000\000\000\003\021\000\000\000\000\003\021\000\000\003\021\000\000\000\000\003\021\000\000\003\021\003\021\003\021\000\000\003\021\003\021\003\021\000\000\000\000\000\000\000\000\000\000\003\021\003\021\003\021\003\021\003\021\000\000\003\021\000\000\000\000\000\000\000\000\000\000\003\021\003\021\003\021\003\021\003\021\000\000\000\000\000\000\000\000\003\021\000\000\003\021\003\021\000\000\000\000\000\000\000\000\003\021\003\021\003\021\000\000\000\000\000\000\000\000\000\000\000\000\003\021\003\021\003\021\003\021\003\021\003\021\003\021\003\021\003\021\000\000\000\000\003\021\000\000\003\021\003\021\003\021\000\000\000\000\000\000\000\000\000\000\000\000\003\021\003\021\003\021\000\000\003\021\003\021\003\021\003\021\000\000\000\000\000\000\000\000\000\000\003\021\000\000\003\021\003\021\000\000\tF\003\021\003\021\003\021\003\021\003\021\000\000\000\000\003\021\003\021\tZ\000\000\000\000\000\000\000\000\003\021\003\021\003\021\003\021\003\017\000\000\000\000\000\000\003\017\000\000\000\000\003\017\000\000\000\000\003\017\000\000\003\017\000\000\000\000\n\198\000\000\003\017\003\017\003\017\000\000\003\017\003\017\003\017\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\003\017\000\000\000\000\000\000\000\000\000\000\003\017\003\017\011\190\011\214\003\017\000\000\000\000\000\000\000\000\003\017\000\000\011\238\003\017\000\000\000\000\000\000\000\000\003\017\003\017\000\238\000\000\000\000\000\000\000\000\000\000\000\000\003\017\003\017\n\222\011^\012\006\012\030\012N\003\017\003\017\000\000\000\000\003\017\000\000\003\017\003\017\012f\000\000\000\000\000\000\000\000\000\000\000\000\003\017\003\017\012~\000\000\003\017\003\017\003\017\003\017\000\000\000\000\000\000\000\000\000\000\003\017\000\000\003\017\003\017\000\000\012\222\003\017\012\246\0126\003\017\003\017\000\000\000\000\003\017\012\150\003\017\000\000\000\000\000\000\000\000\003\017\003\017\012\174\012\198\t\137\000\000\000\000\000\000\t\137\000\000\000\000\t\137\000\000\000\000\t\137\000\000\t\137\000\000\000\000\n\198\000\000\t\137\t\137\t\137\000\000\t\137\t\137\t\137\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\t\137\000\000\000\000\000\000\000\000\000\000\t\137\t\137\011\190\011\214\t\137\000\000\000\000\000\000\000\000\t\137\000\000\011\238\t\137\000\000\000\000\000\000\000\000\t\137\t\137\000\238\000\000\000\000\000\000\000\000\000\000\000\000\t\137\t\137\n\222\011^\012\006\012\030\012N\t\137\t\137\000\000\000\000\t\137\000\000\t\137\t\137\012f\000\000\000\000\000\000\000\000\000\000\000\000\t\137\t\137\012~\000\000\t\137\t\137\t\137\t\137\000\000\000\000\000\000\000\000\000\000\t\137\000\000\t\137\t\137\000\000\t\137\t\137\t\137\0126\t\137\t\137\000\000\000\000\t\137\012\150\t\137\000\000\000\000\000\000\000\000\t\137\t\137\012\174\012\198\003e\000\000\000\000\000\000\003e\000\000\000\000\003e\000\000\000\000\003e\000\000\003e\000\000\000\000\003e\000\000\003e\003e\003e\000\000\003e\003e\003e\000\000\000\000\000\000\000\000\000\000\003e\003e\003e\003e\003e\000\000\003e\000\000\000\000\000\000\000\000\000\000\003e\003e\003e\003e\003e\000\000\000\000\000\000\000\000\003e\000\000\003e\003e\000\000\000\000\000\000\000\000\003e\003e\003e\000\000\000\000\000\000\000\000\000\000\000\000\003e\003e\003e\003e\003e\003e\003e\003e\003e\000\000\000\000\003e\000\000\003e\003e\003e\000\000\000\000\000\000\000\000\000\000\000\000\003e\003e\003e\000\000\003e\003e\003e\003e\000\000\000\000\000\000\000\000\000\000\003e\000\000\003e\003e\000\000\tF\003e\003e\003e\003e\003e\000\000\000\000\003e\003e\tZ\000\000\000\000\000\000\000\000\003e\003e\003e\003e\003a\000\000\000\000\000\000\003a\000\000\000\000\003a\000\000\000\000\003a\000\000\003a\000\000\000\000\n\198\000\000\003a\003a\003a\000\000\003a\003a\003a\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\003a\000\000\000\000\000\000\000\000\000\000\003a\003a\011\190\011\214\003a\000\000\000\000\000\000\000\000\003a\000\000\011\238\003a\000\000\000\000\000\000\000\000\003a\003a\000\238\000\000\000\000\000\000\000\000\000\000\000\000\003a\003a\n\222\011^\012\006\012\030\012N\003a\003a\000\000\000\000\003a\000\000\003a\003a\012f\000\000\000\000\000\000\000\000\000\000\000\000\003a\003a\012~\000\000\003a\003a\003a\003a\000\000\000\000\000\000\000\000\000\000\003a\000\000\003a\003a\000\000\012\222\003a\012\246\0126\003a\003a\000\000\000\000\003a\012\150\003a\000\000\000\000\000\000\000\000\003a\003a\012\174\012\198\003\133\000\000\000\000\000\000\003\133\000\000\000\000\003\133\000\000\000\000\003\133\000\000\003\133\000\000\000\000\003\133\000\000\003\133\003\133\003\133\000\000\003\133\003\133\003\133\000\000\000\000\000\000\000\000\000\000\003\133\003\133\003\133\003\133\003\133\000\000\003\133\000\000\000\000\000\000\000\000\000\000\003\133\003\133\003\133\003\133\003\133\000\000\000\000\000\000\000\000\003\133\000\000\003\133\003\133\000\000\000\000\000\000\000\000\003\133\003\133\003\133\000\000\000\000\000\000\000\000\000\000\000\000\003\133\003\133\003\133\003\133\003\133\003\133\003\133\003\133\003\133\000\000\000\000\003\133\000\000\003\133\003\133\003\133\000\000\000\000\000\000\000\000\000\000\000\000\003\133\003\133\003\133\000\000\003\133\003\133\003\133\003\133\000\000\000\000\000\000\000\000\000\000\003\133\000\000\003\133\003\133\000\000\tF\003\133\003\133\003\133\003\133\003\133\000\000\000\000\003\133\003\133\tZ\000\000\000\000\000\000\000\000\003\133\003\133\003\133\003\133\003\129\000\000\000\000\000\000\003\129\000\000\000\000\003\129\000\000\000\000\003\129\000\000\003\129\000\000\000\000\n\198\000\000\003\129\003\129\003\129\000\000\003\129\003\129\003\129\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\003\129\000\000\000\000\000\000\000\000\000\000\003\129\003\129\011\190\011\214\003\129\000\000\000\000\000\000\000\000\003\129\000\000\011\238\003\129\000\000\000\000\000\000\000\000\003\129\003\129\000\238\000\000\000\000\000\000\000\000\000\000\000\000\003\129\003\129\n\222\011^\012\006\012\030\012N\003\129\003\129\000\000\000\000\003\129\000\000\003\129\003\129\012f\000\000\000\000\000\000\000\000\000\000\000\000\003\129\003\129\012~\000\000\003\129\003\129\003\129\003\129\000\000\000\000\000\000\000\000\000\000\003\129\000\000\003\129\003\129\000\000\012\222\003\129\012\246\0126\003\129\003\129\000\000\000\000\003\129\012\150\003\129\000\000\000\000\000\000\000\000\003\129\003\129\012\174\012\198\003u\000\000\000\000\000\000\003u\000\000\000\000\003u\000\000\000\000\003u\000\000\003u\000\000\000\000\003u\000\000\003u\003u\003u\000\000\003u\003u\003u\000\000\000\000\000\000\000\000\000\000\003u\003u\003u\003u\003u\000\000\003u\000\000\000\000\000\000\000\000\000\000\003u\003u\003u\003u\003u\000\000\000\000\000\000\000\000\003u\000\000\003u\003u\000\000\000\000\000\000\000\000\003u\003u\003u\000\000\000\000\000\000\000\000\000\000\000\000\003u\003u\003u\003u\003u\003u\003u\003u\003u\000\000\000\000\003u\000\000\003u\003u\003u\000\000\000\000\000\000\000\000\000\000\000\000\003u\003u\003u\000\000\003u\003u\003u\003u\000\000\000\000\000\000\000\000\000\000\003u\000\000\003u\003u\000\000\tF\003u\003u\003u\003u\003u\000\000\000\000\003u\003u\tZ\000\000\000\000\000\000\000\000\003u\003u\003u\003u\003q\000\000\000\000\000\000\003q\000\000\000\000\003q\000\000\000\000\003q\000\000\003q\000\000\000\000\n\198\000\000\003q\003q\003q\000\000\003q\003q\003q\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\003q\000\000\000\000\000\000\000\000\000\000\003q\003q\011\190\011\214\003q\000\000\000\000\000\000\000\000\003q\000\000\011\238\003q\000\000\000\000\000\000\000\000\003q\003q\000\238\000\000\000\000\000\000\000\000\000\000\000\000\003q\003q\n\222\011^\012\006\012\030\012N\003q\003q\000\000\000\000\003q\000\000\003q\003q\012f\000\000\000\000\000\000\000\000\000\000\000\000\003q\003q\012~\000\000\003q\003q\003q\003q\000\000\000\000\000\000\000\000\000\000\003q\000\000\003q\003q\000\000\012\222\003q\012\246\0126\003q\003q\000\000\000\000\003q\012\150\003q\000\000\000\000\000\000\000\000\003q\003q\012\174\012\198\003M\000\000\000\000\000\000\003M\000\000\000\000\003M\000\000\000\000\003M\000\000\003M\000\000\000\000\003M\000\000\003M\003M\003M\000\000\003M\003M\003M\000\000\000\000\000\000\000\000\000\000\003M\003M\003M\003M\003M\000\000\003M\000\000\000\000\000\000\000\000\000\000\003M\003M\003M\003M\003M\000\000\000\000\000\000\000\000\003M\000\000\003M\003M\000\000\000\000\000\000\000\000\003M\003M\003M\000\000\000\000\000\000\000\000\000\000\000\000\003M\003M\003M\003M\003M\003M\003M\003M\003M\000\000\000\000\003M\000\000\003M\003M\003M\000\000\000\000\000\000\000\000\000\000\000\000\003M\003M\003M\000\000\003M\003M\003M\003M\000\000\000\000\000\000\000\000\000\000\003M\000\000\003M\003M\000\000\tF\003M\003M\003M\003M\003M\000\000\000\000\003M\003M\tZ\000\000\000\000\000\000\000\000\003M\003M\003M\003M\003I\000\000\000\000\000\000\003I\000\000\000\000\003I\000\000\000\000\003I\000\000\003I\000\000\000\000\n\198\000\000\003I\003I\003I\000\000\003I\003I\003I\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\003I\000\000\000\000\000\000\000\000\000\000\003I\003I\011\190\011\214\003I\000\000\000\000\000\000\000\000\003I\000\000\011\238\003I\000\000\000\000\000\000\000\000\003I\003I\000\238\000\000\000\000\000\000\000\000\000\000\000\000\003I\003I\n\222\011^\012\006\012\030\012N\003I\003I\000\000\000\000\003I\000\000\003I\003I\012f\000\000\000\000\000\000\000\000\000\000\000\000\003I\003I\012~\000\000\003I\003I\003I\003I\000\000\000\000\000\000\000\000\000\000\003I\000\000\003I\003I\000\000\012\222\003I\012\246\0126\003I\003I\000\000\000\000\003I\012\150\003I\000\000\000\000\000\000\000\000\003I\003I\012\174\012\198\003]\000\000\000\000\000\000\003]\000\000\000\000\003]\000\000\000\000\003]\000\000\003]\000\000\000\000\003]\000\000\003]\003]\003]\000\000\003]\003]\003]\000\000\000\000\000\000\000\000\000\000\003]\003]\003]\003]\003]\000\000\003]\000\000\000\000\000\000\000\000\000\000\003]\003]\003]\003]\003]\000\000\000\000\000\000\000\000\003]\000\000\003]\003]\000\000\000\000\000\000\000\000\003]\003]\003]\000\000\000\000\000\000\000\000\000\000\000\000\003]\003]\003]\003]\003]\003]\003]\003]\003]\000\000\000\000\003]\000\000\003]\003]\003]\000\000\000\000\000\000\000\000\000\000\000\000\003]\003]\003]\000\000\003]\003]\003]\003]\000\000\000\000\000\000\000\000\000\000\003]\000\000\003]\003]\000\000\tF\003]\003]\003]\003]\003]\000\000\000\000\003]\003]\tZ\000\000\000\000\000\000\000\000\003]\003]\003]\003]\003Y\000\000\000\000\000\000\003Y\000\000\000\000\003Y\000\000\000\000\003Y\000\000\003Y\000\000\000\000\n\198\000\000\003Y\003Y\003Y\000\000\003Y\003Y\003Y\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\003Y\000\000\000\000\000\000\000\000\000\000\003Y\003Y\011\190\011\214\003Y\000\000\000\000\000\000\000\000\003Y\000\000\011\238\003Y\000\000\000\000\000\000\000\000\003Y\003Y\000\238\000\000\000\000\000\000\000\000\000\000\000\000\003Y\003Y\n\222\011^\012\006\012\030\012N\003Y\003Y\000\000\000\000\003Y\000\000\003Y\003Y\012f\000\000\000\000\000\000\000\000\000\000\000\000\003Y\003Y\012~\000\000\003Y\003Y\003Y\003Y\000\000\000\000\000\000\000\000\000\000\003Y\000\000\003Y\003Y\000\000\012\222\003Y\012\246\0126\003Y\003Y\000\000\000\000\003Y\012\150\003Y\000\000\000\000\000\000\000\000\003Y\003Y\012\174\012\198\003U\000\000\000\000\000\000\003U\000\000\000\000\003U\000\000\000\000\003U\000\000\003U\000\000\000\000\003U\000\000\003U\003U\003U\000\000\003U\003U\003U\000\000\000\000\000\000\000\000\000\000\003U\003U\003U\003U\003U\000\000\003U\000\000\000\000\000\000\000\000\000\000\003U\003U\003U\003U\003U\000\000\000\000\000\000\000\000\003U\000\000\003U\003U\000\000\000\000\000\000\000\000\003U\003U\003U\000\000\000\000\000\000\000\000\000\000\000\000\003U\003U\003U\003U\003U\003U\003U\003U\003U\000\000\000\000\003U\000\000\003U\003U\003U\000\000\000\000\000\000\000\000\000\000\000\000\003U\003U\003U\000\000\003U\003U\003U\003U\000\000\000\000\000\000\000\000\000\000\003U\000\000\003U\003U\000\000\tF\003U\003U\003U\003U\003U\000\000\000\000\003U\003U\tZ\000\000\000\000\000\000\000\000\003U\003U\003U\003U\003Q\000\000\000\000\000\000\003Q\000\000\000\000\003Q\000\000\000\000\003Q\000\000\003Q\000\000\000\000\n\198\000\000\003Q\003Q\003Q\000\000\003Q\003Q\003Q\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\003Q\000\000\000\000\000\000\000\000\000\000\003Q\003Q\011\190\011\214\003Q\000\000\000\000\000\000\000\000\003Q\000\000\011\238\003Q\000\000\000\000\000\000\000\000\003Q\003Q\000\238\000\000\000\000\000\000\000\000\000\000\000\000\003Q\003Q\n\222\011^\012\006\012\030\012N\003Q\003Q\000\000\000\000\003Q\000\000\003Q\003Q\012f\000\000\000\000\000\000\000\000\000\000\000\000\003Q\003Q\012~\000\000\003Q\003Q\003Q\003Q\000\000\000\000\000\000\000\000\000\000\003Q\000\000\003Q\003Q\000\000\012\222\003Q\012\246\0126\003Q\003Q\000\000\000\000\003Q\012\150\003Q\000\000\000\000\000\000\000\000\003Q\003Q\012\174\012\198\003m\000\000\000\000\000\000\003m\000\000\000\000\003m\000\000\000\000\003m\000\000\003m\000\000\000\000\003m\000\000\003m\003m\003m\000\000\003m\003m\003m\000\000\000\000\000\000\000\000\000\000\003m\003m\003m\003m\003m\000\000\003m\000\000\000\000\000\000\000\000\000\000\003m\003m\003m\003m\003m\000\000\000\000\000\000\000\000\003m\000\000\003m\003m\000\000\000\000\000\000\000\000\003m\003m\003m\000\000\000\000\000\000\000\000\000\000\000\000\003m\003m\003m\003m\003m\003m\003m\003m\003m\000\000\000\000\003m\000\000\003m\003m\003m\000\000\000\000\000\000\000\000\000\000\000\000\003m\003m\003m\000\000\003m\003m\003m\003m\000\000\000\000\000\000\000\000\000\000\003m\000\000\003m\003m\000\000\tF\003m\003m\003m\003m\003m\000\000\000\000\003m\003m\tZ\000\000\000\000\000\000\000\000\003m\003m\003m\003m\003i\000\000\000\000\000\000\003i\000\000\000\000\003i\000\000\000\000\003i\000\000\003i\000\000\000\000\n\198\000\000\003i\003i\003i\000\000\003i\003i\003i\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\003i\000\000\000\000\000\000\000\000\000\000\003i\003i\011\190\011\214\003i\000\000\000\000\000\000\000\000\003i\000\000\011\238\003i\000\000\000\000\000\000\000\000\003i\003i\000\238\000\000\000\000\000\000\000\000\000\000\000\000\003i\003i\n\222\011^\012\006\012\030\012N\003i\003i\000\000\000\000\003i\000\000\003i\003i\012f\000\000\000\000\000\000\000\000\000\000\000\000\003i\003i\012~\000\000\003i\003i\003i\003i\000\000\000\000\000\000\000\000\000\000\003i\000\000\003i\003i\000\000\012\222\003i\012\246\0126\003i\003i\000\000\000\000\003i\012\150\003i\000\000\000\000\000\000\000\000\003i\003i\012\174\012\198\003\141\000\000\000\000\000\000\003\141\000\000\000\000\003\141\000\000\000\000\003\141\000\000\003\141\000\000\000\000\003\141\000\000\003\141\003\141\003\141\000\000\003\141\003\141\003\141\000\000\000\000\000\000\000\000\000\000\003\141\003\141\003\141\003\141\003\141\000\000\003\141\000\000\000\000\000\000\000\000\000\000\003\141\003\141\003\141\003\141\003\141\000\000\000\000\000\000\000\000\003\141\000\000\003\141\003\141\000\000\000\000\000\000\000\000\003\141\003\141\003\141\000\000\000\000\000\000\000\000\000\000\000\000\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\003\141\000\000\000\000\003\141\000\000\003\141\003\141\003\141\000\000\000\000\000\000\000\000\000\000\000\000\003\141\003\141\003\141\000\000\003\141\003\141\003\141\003\141\000\000\000\000\000\000\000\000\000\000\003\141\000\000\003\141\003\141\000\000\tF\003\141\003\141\003\141\003\141\003\141\000\000\000\000\003\141\003\141\tZ\000\000\000\000\000\000\000\000\003\141\003\141\003\141\003\141\003\137\000\000\000\000\000\000\003\137\000\000\000\000\003\137\000\000\000\000\003\137\000\000\003\137\000\000\000\000\n\198\000\000\003\137\003\137\003\137\000\000\003\137\003\137\003\137\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\003\137\000\000\000\000\000\000\000\000\000\000\003\137\003\137\011\190\011\214\003\137\000\000\000\000\000\000\000\000\003\137\000\000\011\238\003\137\000\000\000\000\000\000\000\000\003\137\003\137\000\238\000\000\000\000\000\000\000\000\000\000\000\000\003\137\003\137\n\222\011^\012\006\012\030\012N\003\137\003\137\000\000\000\000\003\137\000\000\003\137\003\137\012f\000\000\000\000\000\000\000\000\000\000\000\000\003\137\003\137\012~\000\000\003\137\003\137\003\137\003\137\000\000\000\000\000\000\000\000\000\000\003\137\000\000\003\137\003\137\000\000\012\222\003\137\012\246\0126\003\137\003\137\000\000\000\000\003\137\012\150\003\137\000\000\000\000\000\000\000\000\003\137\003\137\012\174\012\198\003}\000\000\000\000\000\000\003}\000\000\000\000\003}\000\000\000\000\003}\000\000\003}\000\000\000\000\003}\000\000\003}\003}\003}\000\000\003}\003}\003}\000\000\000\000\000\000\000\000\000\000\003}\003}\003}\003}\003}\000\000\003}\000\000\000\000\000\000\000\000\000\000\003}\003}\003}\003}\003}\000\000\000\000\000\000\000\000\003}\000\000\003}\003}\000\000\000\000\000\000\000\000\003}\003}\003}\000\000\000\000\000\000\000\000\000\000\000\000\003}\003}\003}\003}\003}\003}\003}\003}\003}\000\000\000\000\003}\000\000\003}\003}\003}\000\000\000\000\000\000\000\000\000\000\000\000\003}\003}\003}\000\000\003}\003}\003}\003}\000\000\000\000\000\000\000\000\000\000\003}\000\000\003}\003}\000\000\tF\003}\003}\003}\003}\003}\000\000\000\000\003}\003}\tZ\000\000\000\000\000\000\000\000\003}\003}\003}\003}\003y\000\000\000\000\000\000\003y\000\000\000\000\003y\000\000\000\000\003y\000\000\003y\000\000\000\000\n\198\000\000\003y\003y\003y\000\000\003y\003y\003y\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\003y\000\000\000\000\000\000\000\000\000\000\003y\003y\011\190\011\214\003y\000\000\000\000\000\000\000\000\003y\000\000\011\238\003y\000\000\000\000\000\000\000\000\003y\003y\000\238\000\000\000\000\000\000\000\000\000\000\000\000\003y\003y\n\222\011^\012\006\012\030\012N\003y\003y\000\000\000\000\003y\000\000\003y\003y\012f\000\000\000\000\000\000\000\000\000\000\000\000\003y\003y\012~\000\000\003y\003y\003y\003y\000\000\000\000\000\000\000\000\000\000\003y\000\000\003y\003y\000\000\012\222\003y\012\246\0126\003y\003y\000\000\000\000\003y\012\150\003y\000\000\000\000\000\000\000\000\003y\003y\012\174\012\198\003E\000\000\000\000\000\000\003E\000\000\000\000\003E\000\000\000\000\003E\000\000\003E\000\000\000\000\003E\000\000\003E\003E\003E\000\000\003E\003E\003E\000\000\000\000\000\000\000\000\000\000\003E\003E\003E\003E\003E\000\000\003E\000\000\000\000\000\000\000\000\000\000\003E\003E\003E\003E\003E\000\000\000\000\000\000\000\000\003E\000\000\003E\003E\000\000\000\000\000\000\000\000\003E\003E\003E\000\000\000\000\000\000\000\000\000\000\000\000\003E\003E\003E\003E\003E\003E\003E\003E\003E\000\000\000\000\003E\000\000\003E\003E\003E\000\000\000\000\000\000\000\000\000\000\000\000\003E\003E\003E\000\000\003E\003E\003E\003E\000\000\000\000\000\000\000\000\000\000\003E\000\000\003E\003E\000\000\tF\003E\003E\003E\003E\003E\000\000\000\000\003E\003E\tZ\000\000\000\000\000\000\000\000\003E\003E\003E\003E\003A\000\000\000\000\000\000\003A\000\000\000\000\003A\000\000\000\000\003A\000\000\003A\000\000\000\000\n\198\000\000\003A\003A\003A\000\000\003A\003A\003A\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\003A\000\000\000\000\000\000\000\000\000\000\003A\003A\011\190\011\214\003A\000\000\000\000\000\000\000\000\003A\000\000\011\238\003A\000\000\000\000\000\000\000\000\003A\003A\000\238\000\000\000\000\000\000\000\000\000\000\000\000\003A\003A\n\222\011^\012\006\012\030\012N\003A\003A\000\000\000\000\003A\000\000\003A\003A\012f\000\000\000\000\000\000\000\000\000\000\000\000\003A\003A\012~\000\000\003A\003A\003A\003A\000\000\000\000\000\000\000\000\000\000\003A\000\000\003A\003A\000\000\012\222\003A\012\246\0126\003A\003A\000\000\000\000\003A\012\150\003A\000\000\000\000\000\000\000\000\003A\003A\012\174\012\198\t\153\000\000\000\000\000\000\t\153\000\000\000\000\t\153\000\000\000\000\t\153\000\000\t\153\000\000\000\000\n\198\000\000\t\153\t\153\t\153\000\000\t\153\t\153\t\153\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\t\153\000\000\000\000\000\000\000\000\000\000\t\153\t\153\011\190\011\214\t\153\000\000\000\000\000\000\000\000\t\153\000\000\011\238\t\153\000\000\000\000\000\000\000\000\t\153\t\153\000\238\000\000\000\000\000\000\000\000\000\000\000\000\t\153\t\153\n\222\011^\012\006\012\030\012N\t\153\t\153\000\000\000\000\t\153\000\000\t\153\t\153\012f\000\000\000\000\000\000\000\000\000\000\000\000\t\153\t\153\012~\000\000\t\153\t\153\t\153\t\153\000\000\000\000\000\000\000\000\000\000\t\153\000\000\t\153\t\153\000\000\t\153\t\153\t\153\0126\t\153\t\153\000\000\000\000\t\153\012\150\t\153\000\000\000\000\000\000\000\000\t\153\t\153\012\174\012\198\t\241\000\000\000\000\000\000\t\241\000\000\000\000\t\241\000\000\000\000\t\241\000\000\t\241\000\000\000\000\t\241\000\000\t\241\t\241\t\241\000\000\t\241\t\241\t\241\000\000\000\000\000\000\000\000\000\000\t\241\t\241\t\241\t\241\t\241\000\000\t\241\000\000\000\000\000\000\000\000\000\000\t\241\t\241\t\241\t\241\t\241\000\000\000\000\000\000\000\000\t\241\000\000\t\241\t\241\000\000\000\000\000\000\000\000\t\241\t\241\t\241\000\000\000\000\000\000\000\000\000\000\000\000\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\t\241\000\000\000\000\t\241\000\000\t\241\t\241\t\241\000\000\000\000\000\000\000\000\000\000\000\000\t\241\t\241\t\241\000\000\t\241\t\241\t\241\t\241\000\000\000\000\000\000\000\000\000\000\t\241\000\000\t\241\t\241\000\000\tF\t\241\t\241\t\241\t\241\t\241\000\000\000\000\t\241\t\241\tZ\000\000\000\000\000\000\000\000\t\241\t\241\t\241\t\241\002U\000\000\000\000\000\000\002U\000\000\000\000\002U\000\000\000\000\002U\000\000\002U\000\000\000\000\002U\000\000\002U\002U\002U\000\000\002U\002U\002U\000\000\000\000\000\000\000\000\000\000\002U\002U\002U\002U\002U\000\000\002U\000\000\000\000\000\000\000\000\000\000\002U\002U\002U\002U\002U\000\000\000\000\000\000\000\000\002U\000\000\002U\002U\000\000\000\000\000\000\000\000\002U\002U\002U\000\000\000\000\000\000\000\000\000\000\000\000\002U\002U\002U\002U\002U\002U\002U\002U\002U\000\000\000\000\002U\000\000\002U\002U\002U\000\000\000\000\000\000\000\000\000\000\000\000\002U\002U\002U\000\000\002U\002U\016\250\002U\000\000\000\000\000\000\000\000\000\000\002U\000\000\002U\002U\000\000\tF\002U\002U\002U\002U\002U\000\000\000\000\002U\002U\tZ\000\000\000\000\000\000\000\000\002U\002U\002U\002U\002M\000\000\000\000\000\000\002M\000\000\000\000\002M\000\000\000\000\002M\000\000\002M\000\000\000\000\002M\000\000\002M\002M\002M\000\000\002M\002M\002M\000\000\000\000\000\000\000\000\000\000\002M\002M\002M\002M\002M\000\000\002M\000\000\000\000\000\000\000\000\000\000\002M\002M\002M\002M\002M\000\000\000\000\000\000\000\000\002M\000\000\002M\002M\000\000\000\000\000\000\000\000\002M\002M\002M\000\000\000\000\000\000\000\000\000\000\000\000\002M\002M\002M\002M\002M\002M\002M\002M\002M\000\000\000\000\002M\000\000\002M\002M\002M\000\000\000\000\000\000\000\000\000\000\000\000\002M\002M\002M\000\000\002M\002M\002M\002M\000\000\000\000\000\000\000\000\000\000\002M\000\000\002M\002M\000\000\tF\002M\002M\002M\002M\002M\000\000\000\000\002M\002M\tZ\000\000\000\000\000\000\000\000\002M\002M\002M\002M\002I\000\000\000\000\000\000\002I\000\000\000\000\002I\000\000\000\000\002I\000\000\002I\000\000\000\000\n\198\000\000\002I\002I\002I\000\000\002I\002I\002I\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\002I\000\000\000\000\000\000\000\000\000\000\002I\002I\011\190\011\214\002I\000\000\000\000\000\000\000\000\002I\000\000\011\238\002I\000\000\000\000\000\000\000\000\002I\002I\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002I\002I\n\222\011^\012\006\012\030\012N\002I\002I\000\000\000\000\002I\000\000\002I\002I\012f\000\000\000\000\000\000\000\000\000\000\000\000\002I\002I\012~\000\000\002I\002I\002I\002I\000\000\000\000\000\000\000\000\000\000\002I\000\000\002I\002I\000\000\012\222\002I\012\246\0126\002I\002I\000\000\000\000\002I\012\150\002I\000\000\000\000\000\000\000\000\002I\002I\012\174\012\198\002Q\000\000\000\000\000\000\002Q\000\000\000\000\002Q\000\000\000\000\002Q\000\000\002Q\000\000\000\000\n\198\000\000\002Q\002Q\002Q\000\000\002Q\002Q\002Q\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\002Q\000\000\000\000\000\000\000\000\000\000\002Q\002Q\011\190\011\214\002Q\000\000\000\000\000\000\000\000\002Q\000\000\011\238\002Q\000\000\000\000\000\000\000\000\002Q\002Q\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002Q\002Q\n\222\011^\012\006\012\030\012N\002Q\002Q\000\000\000\000\002Q\000\000\002Q\002Q\012f\000\000\000\000\000\000\000\000\000\000\000\000\002Q\002Q\012~\000\000\002Q\002Q\017\022\002Q\000\000\000\000\000\000\000\000\000\000\002Q\000\000\002Q\002Q\000\000\012\222\002Q\012\246\0126\002Q\002Q\000\000\000\000\002Q\012\150\002Q\000\000\000\000\000\000\000\000\002Q\002Q\012\174\012\198\002E\000\000\000\000\000\000\002E\000\000\000\000\002E\000\000\000\000\002E\000\000\002E\000\000\000\000\002E\000\000\002E\002E\002E\000\000\002E\002E\002E\000\000\000\000\000\000\000\000\000\000\002E\002E\002E\002E\002E\000\000\002E\000\000\000\000\000\000\000\000\000\000\002E\002E\002E\002E\002E\000\000\000\000\000\000\000\000\002E\000\000\002E\002E\000\000\000\000\000\000\000\000\002E\002E\002E\000\000\000\000\000\000\000\000\000\000\000\000\002E\002E\002E\002E\002E\002E\002E\002E\002E\000\000\000\000\002E\000\000\002E\002E\002E\000\000\000\000\000\000\000\000\000\000\000\000\002E\002E\002E\000\000\002E\002E\002E\002E\000\000\000\000\000\000\000\000\000\000\002E\000\000\002E\002E\000\000\tF\002E\002E\002E\002E\002E\000\000\000\000\002E\002E\tZ\000\000\000\000\000\000\000\000\002E\002E\002E\002E\002A\000\000\000\000\000\000\002A\000\000\000\000\002A\000\000\000\000\002A\000\000\002A\000\000\000\000\n\198\000\000\002A\002A\002A\000\000\002A\002A\002A\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\002A\000\000\000\000\000\000\000\000\000\000\002A\002A\011\190\011\214\002A\000\000\000\000\000\000\000\000\002A\000\000\011\238\002A\000\000\000\000\000\000\000\000\002A\002A\000\238\000\000\000\000\000\000\000\000\000\000\000\000\002A\002A\n\222\011^\012\006\012\030\012N\002A\002A\000\000\000\000\002A\000\000\002A\002A\012f\000\000\000\000\000\000\000\000\000\000\000\000\002A\002A\012~\000\000\002A\002A\002A\002A\000\000\000\000\000\000\000\000\000\000\002A\000\000\002A\002A\000\000\012\222\002A\012\246\0126\002A\002A\000\000\000\000\002A\012\150\002A\000\000\000\000\000\000\000\000\002A\002A\012\174\012\198\003=\000\000\000\000\000\000\003=\000\000\000\000\003=\000\000\000\000\003=\000\000\003=\000\000\000\000\003=\000\000\003=\003=\003=\000\000\003=\003=\003=\000\000\000\000\000\000\000\000\000\000\003=\003=\003=\003=\003=\000\000\003=\000\000\000\000\000\000\000\000\000\000\003=\003=\003=\003=\003=\000\000\000\000\000\000\000\000\003=\000\000\003=\003=\000\000\000\000\000\000\000\000\003=\003=\003=\000\000\000\000\000\000\000\000\000\000\000\000\003=\003=\003=\003=\003=\003=\003=\003=\003=\000\000\000\000\003=\000\000\003=\003=\003=\000\000\000\000\000\000\000\000\000\000\000\000\003=\003=\003=\000\000\003=\003=\003=\003=\000\000\000\000\000\000\000\000\000\000\003=\000\000\003=\003=\000\000\tF\003=\003=\003=\003=\003=\000\000\000\000\003=\003=\tZ\000\000\000\000\000\000\000\000\003=\003=\003=\003=\0039\000\000\000\000\000\000\0039\000\000\000\000\0039\000\000\000\000\0039\000\000\0039\000\000\000\000\n\198\000\000\0039\0039\0039\000\000\0039\0039\0039\000\000\000\000\000\000\000\000\000\000\011.\011v\011\142\011F\011\166\000\000\0039\000\000\000\000\000\000\000\000\000\000\0039\0039\011\190\011\214\0039\000\000\000\000\000\000\000\000\0039\000\000\011\238\0039\000\000\000\000\000\000\000\000\0039\0039\000\238\000\000\000\000\000\000\000\000\000\000\000\000\0039\0039\n\222\011^\012\006\012\030\012N\0039\0039\000\000\000\000\0039\000\000\0039\0039\012f\000\000\000\000\000\000\000\000\000\000\000\000\0039\0039\012~\000\000\0039\0039\0039\0039\000\000\000\000\000\000\000\000\000\000\0039\000\000\0039\0039\000\000\012\222\0039\012\246\0126\0039\0039\000\000\000\000\0039\012\150\0039\000\000\000\000\000\000\000\000\0039\0039\012\174\012\198\0029\000\000\000\000\000\000\0029\000\000\000\000\0029\000\000\000\000\0029\000\000\0029\000\000\000\000\0029\000\000\0029\0029\0029\000\000\0029\0029\0029\000\000\000\000\000\000\000\000\000\000\0029\0029\0029\0029\0029\000\000\0029\000\000\000\000\000\000\000\000\000\000\0029\0029\0029\0029\0029\000\000\000\000\000\000\000\000\0029\000\000\0029\0029\000\000\000\000\000\000\000\000\0029\0029\0029\000\000\000\000\000\000\000\000\000\000\000\000\0029\0029\0029\0029\0029\0029\0029\0029\0029\000\000\000\000\0029\000\000\0029\0029\0029\000\000\000\000\000\000\000\000\000\000\000\000\0029\0029\0029\000\000\0029\0029\0029\0029\000\000\000\000\000\000\000\000\000\000\0029\000\000\0029\0029\000\000\0029\0029\0029\0029\0029\0029\000\000\000\000\0029\0029\tZ\000\000\000\000\000\000\000\000\0029\0029\0029\0029\002=\000\000\000\000\000\000\002=\000\000\000\000\002=\000\000\000\000\002=\000\000\002=\000\000\000\000\002=\000\000\002=\002=\002=\000\000\002=\002=\002=\000\000\000\000\000\000\000\000\000\000\002=\002=\002=\002=\002=\000\000\002=\000\000\000\000\000\000\000\000\000\000\002=\002=\002=\002=\002=\000\000\000\000\000\000\000\000\002=\000\000\002=\002=\000\000\000\000\000\000\000\000\002=\002=\002=\000\000\000\000\000\000\000\000\000\000\000\000\002=\002=\002=\002=\002=\002=\002=\002=\002=\000\000\000\000\002=\000\000\002=\002=\002=\000\000\000\000\000\000\000\000\000\000\000\000\002=\002=\002=\000\000\002=\002=\002=\002=\000\000\000\000\000\000\000\000\000\000\002=\000\000\002=\002=\000\000\002=\002=\002=\002=\002=\002=\000\000\000\000\002=\002=\tZ\000\000\000\000\000\000\000\000\002=\002=\002=\002=\000\006\000\000\000\000\007\141\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\001\006\000\000\000\000\000\000\002\134\000\000\000\000\000\000\007\141\001\194\000\000\000\000\000\000\003\214\001\014\t\158\t\162\001\026\001\030\000\000\000\000\000\000\002\238\000\000\003\138\000\000\019\002\000\000\t\194\t\198\007\141\003\198\003\210\003\222\t\202\007\006\000\000\001.\007\141\002\162\000\000\000\000\003\218\007\141\007\141\000\238\bf\bj\bv\b\134\000\000\005\138\007\141\007\141\0012\0016\001:\001>\001B\000\000\000\000\b\158\001F\000\000\000\000\000\000\000\000\001J\000\000\b\170\b\194\tf\005\150\005\154\000\000\000\000\001N\000\000\000\000\007\141\000\000\000\000\b~\001R\b\130\000\000\000\000\000\000\000\000\000\000\007\141\000\000\000\000\000\000\001\142\006>\000\000\000\000\005\158\b\146\000\000\001\146\000\000\016\"\004^\t\222\026\214\001\154\000\006\001\158\001\162\001\153\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\001\006\000\000\000\000\000\000\t\154\000\000\000\000\000\000\001\153\001\194\000\000\000\000\000\000\003\214\001\014\t\158\t\162\001\026\001\030\000\000\000\000\000\000\002\238\000\000\003\138\000\000\t\166\000\000\t\194\t\198\001\153\003\198\003\210\003\222\t\202\007\006\000\000\001.\001\153\002\162\000\000\000\000\003\218\001\153\001\153\000\238\bf\bj\bv\b\134\000\000\005\138\001\153\001\153\0012\0016\001:\001>\001B\000\000\000\000\b\158\001F\000\000\000\000\017\250\000\000\001J\002z\b\170\b\194\tf\005\150\005\154\000\000\000\000\001N\001\190\000\000\001\153\000\000\000\000\b~\001R\b\130\000\000\024f\000\000\000\000\028\206\001\153\000\000\000\000\000\000\001\142\006z\000\000\000\000\005\158\b\146\000\000\001\146\000\000\016\"\004^\t\222\017\254\001\154\000\000\001\158\001\162\000\145\002\170\002\174\000\145\000\000\002z\000\000\n*\002\146\018\n\002\230\024\138\000\000\000\145\000\000\000\145\000\000\000\145\000\000\000\145\001\194\000\000\nZ\000\000\002\234\003\130\003R\002\174\000\241\000\000\nb\000\145\000\000\002\238\003V\003\138\005\154\000\145\004\186\000\000\b6\000\145\005\137\003\210\001\174\001\194\000\145\000\241\024\150\000\145\002\162\000\000\000\000\003\218\000\145\000\145\000\145\bf\bj\bv\005\173\014J\005\138\000\145\000\145\024*\000\000\000\000\003~\000\241\000\145\002\250\005\173\000\000\000\145\002\162\000\000\000\241\000\000\000\000\000\000\000\000\000\241\005\150\005\154\000\145\000\145\000\000\000\000\000\145\000\145\000\241\000\241\b~\000\000\b\130\006\158\000\000\000\000\t\213\000\000\000\145\005\173\000\000\007\026\000\000\000\000\000\145\000\145\005\158\b\146\000\000\000\000\000\000\tz\004^\000\000\000\145\000\241\000\145\000\169\002\170\002\174\000\169\000\000\002z\000\000\n*\000\000\000\241\002\230\000\000\005\173\000\169\000\000\000\169\005\173\000\169\000\238\000\169\001\194\000\000\nZ\000\000\002\234\000\000\000\000\000\000\000\000\000\000\nb\000\169\000\000\002\238\000\000\003\138\000\000\000\169\000\000\tU\000\000\000\169\000\000\003\210\001\174\002\158\000\169\001\241\000\000\000\169\002\162\021\182\000\000\003\218\000\169\000\169\000\169\bf\bj\bv\000\000\014J\005\138\000\169\000\169\006N\000\000\000\000\005\250\000\000\000\169\000\000\000\000\t\213\000\169\006b\000\n\000\000\tU\006j\000\000\000\000\000\000\005\150\005\154\000\169\000\169\000\000\000\000\000\169\000\169\000\000\001\241\b~\000\000\b\130\000\000\000\000\000\000\000\000\tU\000\169\001\190\000\000\001\241\001\241\000\000\000\169\000\169\005\158\b\146\000\000\000\000\000\000\tz\004^\000\000\000\169\000\006\000\169\001\194\000\246\002\170\002\174\002\178\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\021\226\003^\tU\000\000\000\000\005\029\004\218\003b\001\194\tU\020&\002\146\002\234\022Z\003f\003j\000\000\002\162\000\000\003n\000\000\002\238\000\000\003\138\022r\019\186\tQ\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\020\030\002\162\000\000\000\000\003\218\0206\001\186\001\190\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020>\000\000\b\158\000\000\001\194\001\234\000\000\tQ\b\190\000\000\b\170\b\194\tf\005\150\005\154\020R\020\142\000\000\000\000\005\029\005\029\000\000\000\000\b~\000\249\b\130\000\000\001\230\002\154\tQ\000\000\000\000\002\150\000\000\002\162\004\014\004\026\020\202\024\190\005\158\b\146\004&\000\000\000\249\tz\004^\t\222\000\006\016\206\000\000\000\246\002\170\002\174\002\178\002\218\002z\000\000\000\000\004*\000\000\002\230\000\000\028\214\005=\tQ\000\249\000\238\021\234\004\218\003b\001\194\tQ\000\000\000\249\002\234\000\000\003f\003j\000\249\000\000\028\194\003n\000\000\002\238\000\000\003\138\000\000\019\186\000\249\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\020\030\002\162\000\000\000\000\003\218\0206\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\006N\000\249\000\000\005\250\000\000\000\000\000\000\020>\000\000\b\158\006b\030\210\000\249\000\000\006j\000\000\000\000\b\170\b\194\tf\005\150\005\154\020R\020\142\000\000\000\000\030\243\017.\000\000\000\000\b~\000\000\b\130\000\000\000\000\000\000\000\000\000\000\017\250\000\000\000\000\002z\000\000\r\005\012\241\024\190\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\000\006\000\000\000\000\000\246\002\170\002\174\002\178\002\218\002z\r\005\000\000\000\000\002\022\002\230\000\000\002\026\031\"\000\000\000\000\000\000\000\000\000\000\003b\001\194\000\000\017\254\000\000\002\234\002&\003f\003j\002.\012\241\000\000\003n\000\000\002\238\000\000\003\138\018\n\019\186\024j\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\020\030\002\162\000\000\0022\003\218\0206\001\254\000\000\bf\bj\bv\b\134\000\000\005\138\005\154\000\000\002\002\000\000\000\000\0076\000\000\020>\000\000\b\158\001\194\030\210\024v\000\000\000\000\000\000\000\000\b\170\b\194\tf\005\150\005\154\020R\020\142\000\000\000\000\005E\003B\000\000\024*\b~\000\000\b\130\0072\001\206\000\000\0026\000\000\000\000\000\000\002\162\000\000\000\000\000\000\000\000\024\190\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\000\014\000\018\000\022\000\026\000\030\000\000\000\"\000&\000*\000.\0002\000\000\0006\000:\000\000\007>\000>\000\000\001\241\000\000\000B\001\241\000\000\000\000\000\000\000\000\000\000\000F\000\000\000\000\000\000\000\000\000\000\000J\000\000\000N\000R\000V\000Z\000^\000b\000f\000\000\000\000\000\n\000j\000n\000\000\000r\000\000\000v\000\000\rE\000\000\000\000\000\000\000\000\000\000\000\000\001\241\000\000\000\000\000\000\000\000\000z\000\000\000\000\000~\000\130\000\000\000\000\rE\001\241\001\241\000\134\000\138\000\142\000\000\000\000\000\000\000\000\000\000\000\000\000\146\000\150\000\154\000\158\000\000\000\162\000\166\000\170\000\000\000\000\rE\000\174\000\178\000\182\000\000\000\000\000\000\001\241\rE\000\186\000\000\000\190\000\194\rE\rE\000\238\000\000\000\000\000\000\000\198\000\000\000\202\rE\rE\000\000\000\000\000\000\000\206\000\210\000\000\000\214\004y\002\254\002\174\004y\000\000\002z\000\000\006\214\000\000\000\000\002\230\000\000\000\000\004y\000\000\000\000\000\000\004y\rE\004y\001\194\000\000\006\246\000\000\000\000\001\241\001\241\003\002\000\000\rE\b\206\004y\000\000\000\000\000\000\000\000\000\000\004y\000\000\000\000\003\014\000\000\000\000\b\250\001\174\001\241\004y\000\000\001\241\004y\002\162\001\241\000\n\003\234\004y\004y\011%\003\238\001\241\003\246\000\000\t\n\005\138\000\000\001\241\000\000\000\000\001\241\001\241\000\000\004y\004y\000\000\000\000\005\142\000\000\000\000\000\000\000\000\000\000\001\241\000\000\000\000\005\150\005\154\004y\004y\r\026\000\000\004y\004y\001\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011%\n6\000\000\011%\r\"\004y\005\158\000\000\000\000\000\000\011%\000\000\004^\000\000\011%\000\000\004y\002\254\002\174\006\026\000\000\002z\000\000\000\000\000\000\000\000\002\230\001\006\000\000\000\000\000\000\002\134\000\000\000\000\000\000\001\241\001\194\000\000\001\241\001\241\001\n\001\014\001\018\003\030\001\026\001\030\001\241\000\000\000\000\000\000\000\000\000\000\000\000\003\"\000\000\001\"\006:\001\241\000\000\003\026\001\174\001*\000\000\000\000\001.\000\n\002\162\000\000\000\000\003\234\000\000\000\000\000\000\003\238\000\000\003\246\005~\000\000\005\138\000\000\001\241\0012\0016\001:\001>\001B\000\000\001\241\000\000\001F\005\142\000\000\000\000\001\241\001J\000\000\000\000\000\000\000\000\005\150\005\154\000\000\005\218\001N\000\000\000\000\000\000\000\000\000\000\000\000\001R\000\000\000\000\000\000\000\000\000\000\001\241\000\000\000\000\000\000\000\000\001\142\006>\000\000\000\000\005\158\000\000\000\000\001\146\000\000\001\150\004^\000\000\000\000\001\154\000\000\001\158\001\162\002\254\002\174\b\254\000\000\002z\000\000\000\000\000\000\000\000\002\230\001\006\000\000\000\000\003r\002\134\000\000\000\000\000\000\000\000\001\194\000\000\000\000\000\000\001\n\001\014\001\018\003\030\001\026\001\030\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\"\000\000\001\"\006:\000\000\000\000\003\026\001\174\001*\000\000\000\000\001.\000\000\002\162\000\000\000\000\003\234\001\241\000\000\000\000\003\238\000\000\003\246\005~\000\000\005\138\000\000\001\241\0012\0016\001:\001>\001B\000\000\000\000\001\241\001F\005\142\000\000\000\000\000\000\001J\000\000\000\n\000\000\000\000\005\150\005\154\000\000\005\218\001N\000\000\001\241\000\000\000\000\000\000\000\000\001R\001\241\001\241\000\000\000\000\000\000\000\000\000\000\001\241\000\000\000\000\001\142\006>\000\000\001\241\005\158\000\000\000\000\001\146\000\000\001\150\004^\000\000\000\000\001\154\000\006\001\158\001\162\000\246\002\170\002\174\002\n\002\218\002z\000\000\000\000\000\000\001\241\002\230\000\000\000\000\020\206\000\000\t\189\000\000\t\189\t\189\003b\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\020\210\000\000\002\238\000\000\003\138\000\000\020\250\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\020\030\002\162\000\000\000\000\003\218\0206\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\021\142\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\254\b\194\tf\005\150\005\154\020R\021\162\000\000\000\000\005\017\005\017\000\000\000\000\b~\000\000\b\130\000\000\000\000\000\000\000\006\000\000\000\000\000\000\002\170\002\174\000\000\002\218\002z\021\178\005\158\b\146\t\189\002\230\000\000\tz\004^\t\222\t\181\000\000\t\181\t\181\000\000\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\001\241\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\001\241\001\241\000\000\002\162\001\241\000\000\003\218\000\000\001\241\001\241\bf\bj\bv\b\134\000\000\005\138\000\000\000\n\000\000\001\241\000\000\000\000\000\000\000\000\000\000\b\158\001\241\000\n\000\000\000\000\001\241\000\000\001\241\t\254\b\194\tf\005\150\005\154\001\241\001\241\000\000\000\000\001\241\001\241\000\000\001\241\b~\001\241\b\130\001\241\000\000\001\241\001\241\001\241\001\241\001\241\001\241\001\241\001\241\001\241\001\241\001\241\005\158\b\146\t\181\000\000\001\241\tz\004^\t\222\001\241\000\000\001\241\001\241\001\241\000\000\001\241\001\241\000\n\001\241\001\241\007\n\001\241\001\241\000\000\001\241\000\000\017\178\000\000\001\241\001\241\001\241\001\241\001\241\001\241\001\241\001\241\000\000\000\000\001\241\001\241\000\000\000\000\001\241\000\000\000\000\001\241\001\241\001\241\001\241\001\241\001\241\001\241\000\000\001\241\000\000\000\000\000\000\000\n\000\000\000\000\000\000\001\241\000\000\001\241\000\000\000\000\000\000\000\000\000\000\001\241\001\241\001\241\001\241\001\241\005\173\017\238\000\000\000\000\005\173\001\241\005\173\005\173\001\241\000\000\001\241\001\241\000\000\000\000\000\000\005\173\000\000\005\173\005\173\005\173\000\000\005\173\005\173\005\173\001\241\001\241\000\000\000\000\000\000\001\241\001\241\001\241\000\000\000\000\001\241\005\173\000\000\000\000\000\000\000\000\000\000\005\173\005\173\000\000\000\000\005\173\000\000\005\173\005\173\005\173\005\173\000\000\000\000\005\173\000\000\000\000\000\000\000\000\005\173\005\173\005\173\000\000\005\173\000\000\005\173\000\000\005\173\005\173\005\173\007\014\000\000\000\000\000\000\000\000\005\173\000\000\000\000\000\000\005\173\000\000\000\000\000\000\005\173\000\000\005\173\005\173\000\000\000\000\000\000\005\173\005\173\005\173\000\000\005\173\005\173\000\000\005\173\000\000\000\000\024\230\000\000\005\173\005\173\005\173\000\000\005\173\000\000\005\173\005\173\000\000\000\000\002\142\005\173\000\000\000\000\000\000\000\000\005\173\003b\000\000\000\000\005\173\000\006\005\173\005\173\000\000\002\170\002\174\000\000\002\218\002z\000\000\005\173\005\173\005\173\002\230\005\173\005\173\000\000\000\000\025V\000\000\003\242\000\000\000\000\001\194\000\000\000\000\020\030\002\234\000\000\003f\003j\0206\023:\005\173\000\000\000\000\002\238\000\000\003\138\000\000\025\250\026\n\003\190\003\194\005\173\003\198\003\210\003\222\003\230\007\006\000\000\002\174\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\0055\000\000\001\194\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\026\246\000\000\000\000\000\000\024\218\t\254\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\026\022\003\150\000\000\026\026\b~\021\250\b\130\002\162\000\000\000\000\000\000\000\000\000\000\000\000\026J\000\000\000\000\000\000\000\000\000\000\005\158\b\146\018\242\000\000\003b\tz\004^\t\222\011A\000\000\000\246\011A\011A\002\178\000\000\011A\000\000\011A\026Z\000\000\011A\000\000\000\000\005=\011A\011A\022&\011A\011A\003b\011A\000\000\011A\000\000\020\030\r\005\012\241\011A\000\000\0206\011A\003n\000\000\000\000\000\000\000\000\000\000\019\186\011A\022R\011A\000\000\000\000\011A\011A\r\005\027r\000\000\002\022\020\030\011A\002\026\000\000\011A\0206\000\000\011A\011A\002\"\011A\000\000\011A\011A\000\000\002&\005-\000\000\002.\012\241\000\000\020>\000\000\000\000\000\000\011A\000\000\022\182\000\000\000\000\005\t\000\000\000\000\005\t\011A\011A\020R\020\142\011A\000\000\011A\000\000\0022\005\t\000\000\000\000\000\000\005\186\000\000\005\t\000\000\000\000\000\000\000\000\011A\011A\000\000\011A\011A\024\190\011A\005\t\011A\000\000\011A\000A\011A\005\t\011A\000A\000A\000\000\000A\000A\000\000\000\000\005\t\000\000\000A\005\t\000\000\000\000\000\000\007=\005\t\002\210\000\000\000\000\000A\0026\000\000\000\000\000A\000\000\000A\000A\000\000\000\000\000\000\000\000\005\t\000A\000\000\000A\005\t\000\000\000\000\000A\000A\000\000\000A\000A\000A\000A\000A\005\t\005\t\000\000\000A\005\t\000\000\000A\000\000\000\000\000\000\000A\000A\000A\000A\000\000\000A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\t\000\000\000A\000\000\r9\000\000\000\000\000\000\000\000\000\000\000A\000A\000A\000A\000A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\221\000A\000=\000A\005\221\000\000\000=\000=\000\000\000=\000=\000\000\000\000\000\000\000\000\000=\000\000\000A\000A\000\000\0079\000\000\000A\000A\000A\000=\000\000\000\000\000\000\000=\000\000\000=\000=\000\000\000\000\000\000\000\000\000\000\000=\000\000\000=\000\000\000\000\000\000\000=\000=\000\000\000=\000=\000=\000=\000=\000\000\000\000\000\000\000=\000\000\000\000\000=\r9\r9\000\000\000=\000=\000=\000=\000\000\000=\000\000\000\000\000\000\000\000\000\000\005\221\000\000\000\000\000\000\000=\000\000\r9\r9\000\000\000\000\r9\000\000\000=\000=\000=\000=\000=\005\221\000\000\000\000\005\221\000\000\000\000\000\000\005\225\000=\012\149\000=\005\225\000\000\012\149\012\149\000\000\012\149\012\149\000\000\000\000\000\000\000\000\012\149\000\000\000=\000=\000\000\007I\000\000\000=\000=\000=\012\149\000\000\000\000\000\000\012\149\000\000\012\149\012\149\000\000\000\000\000\000\000\000\000\000\012\149\000\000\012\149\000\000\000\000\000\000\012\149\012\149\000\000\012\149\012\149\012\149\012\149\012\149\000\000\000\000\000\000\012\149\000\000\000\000\012\149\r9\r9\000\000\012\149\012\149\012\149\012\149\000\000\012\149\000\000\000\000\000\000\000\000\000\000\005\225\000\000\000\000\000\000\012\149\000\000\000\000\r9\000\000\000\000\r9\000\000\012\149\012\149\012\149\012\149\012\149\005\225\000\000\000\000\005\225\000\000\000\000\000\000\000\000\012\149\012\145\012\149\000\000\000\000\012\145\012\145\000\000\012\145\012\145\000\000\000\000\000\000\000\000\012\145\000\000\012\149\012\149\000\000\007E\000\000\012\149\012\149\012\149\012\145\000\000\000\000\000\000\012\145\000\000\012\145\012\145\000\000\000\000\000\000\000\000\000\000\012\145\000\000\012\145\000\000\000\000\000\000\012\145\012\145\000\000\012\145\012\145\012\145\012\145\012\145\000\000\000\000\000\000\012\145\000\000\000\000\012\145\000\000\000\000\000\000\012\145\012\145\012\145\012\145\000\000\012\145\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\t\012\145\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\145\012\145\012\145\012\145\012\145\000\000\000\000\000\000\000\000\000\000\005\t\000\000\000\000\012\145\000\006\012\145\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\012\145\012\145\000\000\005\t\000\000\012\145\012\145\012\145\001\194\000\000\000\000\005\t\002\234\000\000\003f\003j\005\t\002\210\000\238\000\000\000\000\002\238\000\000\003\138\000\000\005\t\005\t\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\005\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\005\t\000\000\000\000\000\000\000\000\t\254\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\000\b\130\000\000\r\005\012\241\000\006\000\000\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\005\158\b\146\0162\002\230\000\000\tz\004^\t\222\r\005\000\000\016B\002\022\000\000\001\194\002\026\000\000\000\000\002\234\000\000\003f\003j\002\190\000\000\000\000\000\000\000\000\002\238\002&\003\138\000\000\002.\012\241\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\0022\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\254\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\0026\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\019>\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\018\222\b\194\tf\005\150\005\154\012\205\000\000\000\000\000\000\012\205\000\000\001\190\012\205\b~\000\000\b\130\000\000\000\000\000\000\000\000\004\178\000\000\012\205\012\205\012\205\000\000\012\205\012\205\012\205\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\000\000\000\000\000\000\012\205\000\000\000\000\000\000\000\000\000\000\012\205\012\205\000\000\000\000\012\205\000\000\000\000\002\146\000\000\012\205\000\000\000\000\012\205\000\000\000\000\000\000\000\000\012\205\012\205\012\205\000\000\000\000\000\000\000\000\000\000\004\233\012\205\012\205\004\233\000\000\000\000\000\000\000\000\012\205\000\000\000\000\000\000\004\186\004\233\000\000\000\000\012\205\004\233\000\000\004\233\000\000\000\000\000\000\012\205\012\205\012\205\000\000\012\205\012\205\000\000\000\000\004\233\000\000\000\000\000\000\000\000\000\000\004\233\000\000\012\205\000\000\012\205\012\205\000\000\000\000\000\000\012\205\000\000\000\000\004\233\000\000\012\205\000\000\000\000\004\233\012\205\t\165\012\205\012\205\000\000\t\165\000\000\001\190\t\165\000\000\000\000\000\000\000\000\000\000\000\000\004\233\t\165\000\000\t\165\t\165\t\165\000\000\t\165\t\165\t\165\000\000\000\000\000\000\000\000\000\000\004\233\004\233\000\000\000\000\004\233\004\233\t\165\000\000\000\000\000\000\000\000\000\000\t\165\t\165\000\000\000\000\t\165\000\000\000\000\002\146\000\000\t\165\000\000\004\233\t\165\000\000\000\000\000\000\000\000\t\165\t\165\t\165\000\000\000\000\021F\000\000\000\000\004\209\t\165\t\165\004\209\000\000\000\000\000\000\000\000\t\165\000\000\000\000\000\000\004\186\004\209\000\000\000\000\t\165\004\209\000\000\004\209\000\000\000\000\000\000\t\165\t\165\t\165\000\000\t\165\t\165\000\000\000\000\004\209\000\000\000\000\000\000\000\000\000\000\004\209\000\000\t\165\000\000\t\165\t\165\000\000\000\000\000\000\t\165\000\000\000\000\004\209\000\000\t\165\000\000\000\000\004\209\t\165\t\161\t\165\t\165\000\000\t\161\000\000\001\190\t\161\000\000\000\000\000\000\000\000\000\000\000\000\004\209\t\161\000\000\t\161\t\161\t\161\000\000\t\161\t\161\t\161\000\000\000\000\000\000\000\000\000\000\004\209\004\209\000\000\000\000\004\209\004\209\t\161\000\000\000\000\000\000\000\000\000\000\t\161\t\161\000\000\000\000\t\161\000\000\000\000\002\146\000\000\t\161\000\000\004\209\t\161\000\000\000\000\000\000\000\000\t\161\t\161\t\161\000\000\000\000\023\130\000\000\000\000\000\000\t\161\t\161\000\000\000\000\000\000\000\000\000\000\t\161\000\000\000\000\000\000\004\186\000\000\000\000\000\000\t\161\000\000\000\000\000\000\000\000\000\000\000\000\t\161\t\161\t\161\000\000\t\161\t\161\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\161\000\006\t\161\t\161\000\000\002\170\002\174\t\161\002\218\002z\000\000\000\000\t\161\000\000\002\230\000\000\t\161\000\000\t\161\t\161\000\000\000\000\000\000\000\000\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017f\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017>\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t6\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\tJ\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\022\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\138\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\202\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\226\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\006\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0112\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011J\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011b\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011z\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\146\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\170\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\194\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\218\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\242\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\n\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\"\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012:\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012R\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012j\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\130\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\154\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\178\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\202\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\226\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\250\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014f\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\138\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\174\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\214\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\250\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\030\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015J\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015n\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\146\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\174\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\234\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\254\b\194\tf\005\150\005\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b~\000\006\b\130\000\000\000\000\002\170\002\174\000\000\002\218\002z\000\000\000\000\000\000\000\000\002\230\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\001\194\000\000\000\000\000\000\002\234\000\000\003f\003j\000\000\000\000\000\000\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\003\190\003\194\000\000\003\198\003\210\003\222\003\230\007\006\000\000\000\000\000\000\002\162\000\000\000\000\003\218\000\000\000\000\000\000\bf\bj\bv\b\134\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\026\b\194\tf\005\150\005\154\000\000\000y\000\000\000y\000y\000\000\000\000\000\000\b~\000\000\b\130\000\000\000y\000\000\000y\000y\000\000\000\000\000y\000y\000y\000\000\t=\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\t\222\000y\000\000\000\000\000\000\000\000\000\000\000y\000y\000\000\000\000\000y\000\000\000\000\000y\000\000\000y\000\000\000\000\000y\000\000\000\000\000\000\000\000\000y\000y\000y\000\000\000\000\000\000\000\000\000\000\000\000\000y\000y\000\000\000\000\000\000\000\000\000\000\000y\000y\000\000\000\000\000y\000\000\000\000\000\000\000y\000\000\000\000\000\000\000\000\000\000\000\000\000y\000y\000y\012\209\000y\000y\000\000\012\209\000\000\000\000\012\209\000\000\t=\000\000\000\000\000\000\000y\000\000\004v\000y\012\209\012\209\012\209\000y\012\209\012\209\012\209\000\000\000y\000\000\000\000\000\000\000y\000\000\000y\000\000\000\000\000\000\012\209\000\000\000\000\000\000\000\000\000\000\012\209\012\209\000\000\000\000\012\209\000\000\000\000\000\000\000\000\012\209\000\000\000\000\012\209\000\000\000\000\000\000\000\000\012\209\012\209\012\209\000\000\000\000\000\000\000\000\000\000\000\000\012\209\012\209\000\000\000\000\000\000\000\000\000\000\012\209\000\000\000\000\000\000\012\209\000\000\000\000\000\000\012\209\000\000\000\000\000\000\000\000\000\000\000\000\012\209\012\209\012\209\003\177\012\209\012\209\000\000\003\177\000\000\000\000\003\177\000\000\000\000\000\000\000\000\000\000\012\209\000\000\012\209\012\209\003\177\003\177\003\177\012\209\003\177\003\177\003\177\000\000\012\209\000\000\000\000\000\000\012\209\000\000\012\209\012\209\000\000\000\000\003\177\000\000\000\000\000\000\000\000\000\000\003\177\004n\000\000\000\000\003\177\000\000\000\000\000\000\000\000\003\177\000\000\000\000\003\177\000\000\000\000\000\000\000\000\003\177\003\177\003\177\000\000\000\000\000\000\000\000\000\000\000\000\003\177\003\177\000\000\000\000\000\000\000\000\000\000\003\177\000\000\000\000\000\000\003\177\000\000\011M\000\000\003\177\002\254\002\174\000\000\000\000\002z\000\000\003\177\003\177\003\177\002\230\003\177\003\177\000\000\011M\011M\000\000\011M\011M\000\000\001\194\000\000\000\000\003\177\000\000\003\177\003\177\003\002\000\000\000\000\003\177\000\000\000\000\000\000\000\000\003\177\000\000\000\000\011M\003\177\003\014\003\177\003\177\003\026\001\174\000\000\000\000\000\000\001\186\001\190\002\162\000\000\000\000\003\234\000\000\000\000\011M\003\238\000\000\003\246\005~\000\000\005\138\000\000\000\000\000\000\000\000\001\194\001\234\001\214\000\000\000\000\000\000\000\000\005\142\000\000\000\000\001\226\000\000\000\000\021\226\000\000\000\000\005\150\005\154\000\000\005\218\011M\000\000\011M\001\230\0236\000\000\022Z\000\000\002\150\000\000\002\162\004\014\004\026\000\000\000\000\000\000\011M\023F\000\000\011M\011M\000\000\005\158\000\000\011M\000\000\011M\000\000\004^\011I\011M\000\000\002\254\002\174\004*\000\000\002z\000\000\000\000\000\000\000\000\002\230\000\000\000\000\000\000\011I\011I\000\000\011I\011I\000\000\001\194\000\000\000\000\000\000\000\000\000\000\000\000\003\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011I\000\000\003\014\000\000\012\177\006\022\001\174\012\177\000\000\000\000\000\000\000\000\002\162\000\000\000\000\003\234\000\000\012\177\011I\003\238\000\000\003\246\005~\012\177\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\177\005\142\000\000\000\000\000\000\000\000\012\177\000\000\000\000\000\000\005\150\005\154\000\000\005\218\011I\012\177\011I\000\000\012\177\000\000\000\000\000\000\000\000\012\177\000\000\000\000\000\000\000\000\001\177\000\000\011I\000\000\001\177\011I\011I\001\177\005\158\000\000\011I\012\177\011I\000\000\004^\012\177\011I\001\177\001\177\001\177\000\000\001\177\001\177\001\177\000\000\000\000\012\177\012\177\000\000\000\000\012\177\000\000\000\000\000\000\000\000\001\177\000\000\000\000\030\202\000\000\000\000\001\177\001\177\000\000\000\000\001\177\000\000\000\000\000\000\012\177\001\177\000\000\000\000\001\177\000\000\000\000\000\000\000\000\001\177\001\177\001\177\000\000\000\000\000\000\000\000\000\000\000\000\001\177\001\177\000\000\000\000\000\000\000\000\000\000\001\177\000\000\000\000\000\000\001\177\000\000\000\000\000\000\001\177\000\000\000\000\000\000\000\000\000\000\000\000\001\177\001\177\001\177\000\000\001\177\001\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\177\000\000\001\177\001\177\002\254\002\174\000\000\001\177\002z\000\000\006\214\000\000\001\177\002\230\000\000\000\000\004\218\000\000\001\177\000\000\000\000\000\000\000\000\001\194\000\000\006\246\000\000\000\000\000\000\000\000\003\002\000\000\000\000\b\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\014\000\000\000\000\b\250\001\174\000\000\000\000\000\000\000\000\000\000\002\162\000\000\000\000\003\234\000\000\000\000\011%\003\238\000\000\003\246\000\000\t\n\005\138\000\000\000\000\000\000\000\000\000\000\000\000\006%\000\000\004\181\000\000\006%\005\142\000\000\006%\000\000\000\000\000\000\000\000\000\000\000\000\005\150\005\154\000\000\006%\r\026\006%\000\000\006%\000\000\006%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011%\006%\000\000\011%\011%\000\000\005\158\006%\006%\000\000\011%\000\000\004^\006%\011%\004\181\006%\000\000\000\000\006%\000\000\000\000\000\000\000\000\006%\006%\006%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006%\006%\000\000\000\000\006%\003\253\000\000\000\000\000\000\003\253\000\000\000\000\003\253\000\000\000\000\006%\006%\006%\000\000\006%\006%\000\000\003\253\000\000\003\253\000\000\003\253\007\238\003\253\003\253\000\000\000\000\000\000\000\000\006%\000\000\000\000\006%\006%\003\253\003\253\003\253\000\000\003\253\000\000\003\253\003\253\003\253\000\000\006%\000\000\000\000\005\181\000\000\000\000\003\253\000\000\003\253\003\253\000\000\000\000\000\000\000\000\003\253\003\253\003\253\000\000\000\000\000\000\005\185\000\000\000\000\003\253\000\000\000\000\003\253\000\000\000\000\000\000\003\253\003\253\003\253\003\253\003\253\000\000\000\000\000\000\000\000\000\000\000\000\001\186\001\190\000\000\000\000\003\253\003\253\003\253\000\000\003\253\003\253\003\253\006\025\000\000\000\000\000\000\006\025\005\181\000\000\006\025\001\194\001\234\003\253\003\253\003\253\003\253\003\253\003\253\003\253\006\025\000\000\006\025\000\000\006\025\005\185\006\025\000\000\000\000\000\000\003\253\000\000\003\253\003\253\001\230\002\146\003\253\000\000\006\025\002\150\000\000\002\162\004\014\004\026\006\025\006\025\000\000\003\253\004&\000\000\b2\000\000\000\000\006\025\000\000\000\000\006\025\000\000\000\000\000\000\000\000\006\025\006\025\000\238\000\000\004*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\025\006\025\000\000\000\000\006\025\000\000\000\000\n\198\000\000\000\000\014&\t\177\000\000\t\177\t\177\006\025\006\025\006\025\000\000\006\025\006\025\011.\011v\011\142\011F\011\166\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\025\011\190\011\214\006\025\006\025\000\000\000\000\000\000\000\000\000\000\011\238\000\000\000\000\000\000\000\000\006\025\000\000\000\000\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\222\011^\012\006\012\030\012N\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017V\012f\001\006\000\000\000\000\000\000\002\134\000\000\000\000\000\000\012~\000\000\000\000\000\000\000\000\001\n\001\014\001\018\001\022\001\026\001\030\000\000\000\000\000\000\000\000\000\000\012\222\000\000\012\246\0126\001\"\001&\000\000\000\000\t\177\012\150\001*\000\000\000\000\001.\000\000\000\000\000\000\012\174\012\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0012\0016\001:\001>\001B\000\000\000\000\000\000\001F\000\000\000\000\004\249\000\000\001J\004\249\000\000\t\021\000\000\000\000\000\000\t\021\000\000\001N\t\021\004\249\000\000\000\000\000\000\004\249\001R\004\249\000\000\000\000\t\021\000\000\t\021\000\000\t\021\000\000\t\021\001\142\029\230\004\249\000\000\000\000\000\000\000\000\001\146\004\249\001\150\000\000\t\021\000\000\001\154\000\000\001\158\001\162\t\021\t\021\000\000\004\249\000\000\000\000\000\000\000\000\004\249\t\021\000\000\000\000\t\021\000\000\000\000\000\000\000\000\t\021\t\021\t\021\000\000\000\000\000\000\000\000\004\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\021\000\000\000\000\000\000\t\021\000\000\004\249\004\249\000\000\000\000\004\249\004\249\000\000\000\000\000\000\t\021\t\021\t\021\r\133\t\021\t\021\000\000\r\133\000\000\000\000\r\133\000\000\000\000\000\000\004\249\000\000\t\021\000\000\000\000\t\021\r\133\000\000\r\133\t\021\r\133\023\218\r\133\000\000\000\000\000\000\000\000\000\000\004\218\000\000\t\021\000\000\000\000\000\000\r\133\000\000\000\000\000\000\000\000\000\000\r\133\r\133\000\000\000\000\000\000\000\000\0042\000\000\000\000\r\133\000\000\000\000\r\133\000\000\000\000\000\000\000\000\r\133\r\133\r\133\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\186\001\190\000\000\000\000\000\000\000\000\r\133\000\000\000\000\000\000\r\133\r\137\000\000\000\000\000\000\r\137\000\000\000\000\r\137\001\194\001\234\r\133\r\133\r\133\000\000\r\133\r\133\000\000\r\137\000\000\r\137\000\000\r\137\004>\r\137\000\000\000\000\000\000\000\000\000\000\r\133\000\000\001\230\002\154\r\133\000\000\r\137\002\150\000\000\002\162\004\014\004\026\r\137\r\137\000\000\r\133\004&\000\000\0042\000\000\000\000\r\137\000\000\000\000\r\137\000\000\000\000\000\000\000\000\r\137\r\137\r\137\000\000\004*\000\000\000\000\000\000\005}\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\137\000\000\002\254\002\174\r\137\000\000\002z\000\000\006\214\000\000\028\194\002\230\000\000\000\000\000\000\r\137\r\137\r\137\000\000\r\137\r\137\001\194\000\000\006\246\000\000\000\000\000\000\004>\003\002\000\000\000\000\b\206\000\000\000\000\r\137\000\000\000\000\000\000\r\137\003\157\000\000\003\014\000\000\000\000\b\250\001\174\000\000\000\000\000\000\r\137\000\000\002\162\000\000\000\000\003\234\000\000\000\000\000\000\003\238\000\000\003\246\000\000\t\n\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\142\001\161\000\000\001\190\001\161\000\000\000\000\000\000\000\000\005\150\005\154\000\000\t}\003\157\001\161\000\000\000\000\000\000\001\161\000\000\001\161\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\157\000\000\001\161\003\157\000\000\005\158\000\000\000\000\001\161\001\161\000\000\004^\000\000\000\000\000\000\002\146\000\000\001\161\000\000\000\000\001\161\003\225\000\000\001\190\003\225\001\161\001\161\001\161\000\000\000\000\000\000\000\000\ty\000\000\003\225\000\000\000\000\000\000\003\225\000\000\003\225\001\161\001\161\000\000\000\000\004\186\000\000\000\000\000\000\000\000\000\000\000\000\003\225\000\000\000\000\000\000\001\161\001\161\003\225\001\157\001\161\001\161\000\000\000\000\000\000\002\146\000\000\003\225\000\000\000\000\003\225\000\000\001\161\000\000\000\000\003\225\003\225\003\225\000\000\001\161\000\000\000\000\000\000\000\000\001\161\000\000\000\000\000\000\000\000\000\000\001\161\003\225\003\225\000\000\000\000\004\186\000\000\000\000\000\000\000\000\000\000\003\221\000\000\001\190\003\221\000\000\003\225\003\225\000\000\000\000\003\225\003\225\ty\000\000\003\221\000\000\000\000\000\000\003\221\000\000\003\221\000\000\003\225\000\000\000\000\000\000\000\000\000\000\000\000\003\225\000\000\000\000\003\221\000\000\003\225\000\000\000\000\000\000\003\221\001\157\003\225\000\000\000\000\000\000\000\000\002\146\000\000\003\221\000\000\000\000\003\221\000\000\000\000\000\000\000\000\003\221\003\221\003\221\000\000\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\221\003\221\000\000\000\000\004\186\000\000\000\000\000\000\005\001\000\000\000\000\005\001\000\000\000\000\000\000\003\221\003\221\000\000\000\000\003\221\003\221\005\001\000\000\000\000\000\000\005\001\000\000\005\001\000\000\000\000\000\000\003\221\000\000\000\246\001\186\001\190\002\n\000\000\003\221\005\001\000\000\000\000\000\000\003\221\000\000\005\001\020\206\000\000\000\000\003\221\005\017\000\000\003b\001\194\001\234\001\214\000\000\005\001\000\000\000\000\000\000\000\000\005\001\001\226\020\210\000\000\000\000\000\000\000\000\000\000\020\250\000\000\000\000\000\000\000\000\000\000\001\230\002\138\005\001\000\000\000\000\002\150\020\030\002\162\004\014\004\026\000\000\0206\000\000\000\153\004&\000\000\000\153\005\001\005\001\000\000\000\000\005\001\005\001\000\000\000\000\000\000\000\153\021\142\000\153\000\000\000\153\004*\000\153\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\001\000\000\020R\021\162\000\153\000\000\005\017\005\017\000\000\000\000\000\153\024\002\000\000\000\000\000\153\000\000\000\000\000\000\000\000\000\153\000\000\000\000\000\153\000\000\000\000\021\178\000\000\000\153\000\153\000\238\004Z\000\000\004^\000\000\000\000\000\000\000\153\000\153\000\000\000\000\000\000\000\000\000\000\000\153\000\000\000\000\000\000\000\153\000\000\000\000\000\000\000\000\000\221\000\000\000\000\000\221\000\000\000\000\000\153\000\153\000\000\000\000\000\153\000\153\000\000\000\221\000\000\000\221\000\000\000\221\000\000\000\221\000\000\000\000\000\153\000\000\000\000\000\000\000\000\000\000\000\153\000\153\000\000\000\221\000\000\000\000\000\000\000\000\000\000\000\221\000\153\000\000\000\153\000\221\000\000\000\000\000\000\000\000\000\221\000\000\000\000\000\221\000\000\000\000\000\000\000\000\000\221\000\221\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\221\000\221\000\000\000\000\000\000\000\000\000\000\000\221\000\000\000\000\000\000\000\221\000\000\000\000\000\000\000\000\000\161\000\000\000\000\000\161\000\000\000\000\000\221\000\221\000\000\000\000\000\221\000\221\000\000\000\161\000\000\000\161\000\000\000\161\000\000\000\161\000\000\000\000\000\221\000\000\000\000\000\000\000\000\000\000\000\221\000\221\000\000\000\161\000\000\000\000\000\000\000\000\000\000\000\161\000\221\000\000\000\221\000\161\000\000\000\000\000\000\000\000\000\161\000\000\000\000\000\161\000\000\000\000\000\000\000\000\000\161\000\161\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\161\000\161\000\000\000\000\000\000\000\000\000\000\000\161\000\000\000\000\000\000\000\161\000\000\000\000\000\000\000\000\000\157\000\000\000\000\000\157\000\000\000\000\000\161\000\161\000\000\000\000\000\161\000\161\000\000\000\157\000\000\000\157\000\000\000\157\000\000\000\157\000\000\000\000\000\161\000\000\000\000\000\000\000\000\000\000\000\161\000\161\000\000\000\157\000\000\000\000\000\000\000\000\000\000\000\157\000\161\000\000\000\161\000\157\000\000\000\000\000\000\000\000\000\157\000\000\000\000\000\157\000\000\000\000\000\000\000\000\000\157\000\157\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\157\000\157\000\000\001\006\000\000\000\000\000\000\000\157\000\000\000\000\000\000\000\157\000\000\000\000\000\000\000\000\001\n\001\014\001\018\001\022\001\026\001\030\000\157\000\157\000\000\000\000\000\157\000\157\000\000\000\000\000\000\001\"\001&\000\000\000\000\000\000\000\000\001*\000\157\000\000\001.\000\000\000\000\000\000\000\157\000\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\157\000\000\000\157\0012\0016\001:\001>\001B\000\000\000\000\000\000\001F\000\000\000\000\001}\000\000\001J\001}\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001N\000\000\001}\000\000\001\186\001\190\001}\001R\001}\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\142\030\002\001}\001}\000\000\001\194\001\234\001\146\001}\001\150\000\000\000\000\000\000\001\154\005\181\001\158\001\162\001}\000\000\000\000\001}\000\000\000\000\000\000\000\000\001}\001}\001}\001\230\002\146\000\000\000\000\000\000\002\150\000\000\002\162\004\014\004\026\000\000\000\000\000\000\001}\004&\000\000\018\022\001}\r\129\000\000\000\000\000\000\r\129\000\000\000\000\r\129\000\000\000\000\001}\001}\000\000\004*\001}\001}\000\000\r\129\000\000\r\129\000\000\r\129\005\181\r\129\000\000\000\000\001}\000\000\000\000\000\000\000\000\000\000\001}\001}\000\000\r\129\000\000\000\000\001}\000\000\000\000\r\129\r\129\000\000\001}\000\000\000\000\000\000\000\000\000\000\r\129\000\000\000\000\r\129\000\000\000\000\000\000\000\000\r\129\r\129\r\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\129\000\000\000\000\000\000\r\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\129\r\129\r\129\r}\r\129\r\129\000\000\r}\000\000\000\000\r}\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\129\r}\000\000\r}\r\129\r}\000\000\r}\000\000\000\000\t\025\000\000\000\000\004\218\t\025\r\129\000\000\t\025\000\000\r}\000\000\000\000\000\000\000\000\000\000\r}\r}\t\025\000\000\t\025\000\000\t\025\000\000\t\025\r}\000\000\000\000\r}\000\000\000\000\000\000\000\000\r}\r}\r}\t\025\000\000\000\000\000\000\000\000\000\000\t\025\t\025\000\000\000\000\000\000\000\000\000\000\r}\000\000\t\025\000\000\r}\t\025\000\000\000\000\000\000\000\000\t\025\t\025\000\238\000\000\000\000\r}\r}\r}\000\000\r}\r}\000\000\000\000\000\000\000\000\000\000\t\025\000\000\000\000\000\000\t\025\007\138\000\000\000\000\r}\000\000\000\000\n\198\r}\000\000\007\169\t\025\t\025\t\025\007\169\t\025\t\025\000\000\000\000\r}\000\000\011.\011v\011\142\011F\011\166\000\000\t\025\000\000\000\000\t\025\000\000\000\000\000\000\t\025\011\190\011\214\000\000\000\000\000\000\001\157\000\000\001\190\001\157\011\238\t\025\000\000\000\000\000\000\000\000\000\000\ty\000\238\001\157\000\000\000\000\000\000\001\157\000\000\001\157\000\000\n\222\011^\012\006\012\030\012N\000\000\000\000\000\000\000\000\000\000\001\157\007\169\000\000\012f\000\000\000\000\001\157\000\000\000\000\000\000\000\000\000\000\012~\002\146\000\000\001\157\000\000\000\000\001\157\000\000\000\000\000\000\000\000\001\157\001\157\001\157\000\000\000\000\012\222\000\000\012\246\0126\000\000\000\000\000\000\000\000\000\000\012\150\000\000\001\157\001\157\000\000\000\000\004\186\000\000\012\174\012\198\n\198\000\000\000\000\000\000\019z\000\000\000\000\001\157\001\157\000\000\000\000\001\157\001\157\000\000\011.\011v\011\142\011F\011\166\000\000\000\000\000\000\000\000\001\157\000\000\000\000\000\000\000\000\011\190\011\214\001\157\000\000\000\000\000\000\000\000\001\157\000\000\011\238\000\000\000\000\000\000\001\157\000\000\000\000\000\000\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\222\011^\012\006\012\030\012N\000\000\000\000\000\000\000\000\000\000\006M\000\000\000\000\012f\006M\000\000\000\000\006M\000\000\000\000\000\000\000\000\012~\000\000\000\000\000\000\000\000\006M\000\000\006M\000\000\006M\000\000\006M\000\000\000\000\000\000\000\000\012\222\019~\012\246\0126\019\138\000\000\000\000\006M\000\000\012\150\000\000\000\000\000\000\006M\006M\000\000\000\000\012\174\012\198\b2\000\000\000\000\006M\000\000\000\000\006M\000\000\000\000\000\000\000\000\006M\006M\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006M\000\000\000\000\000\000\006M\000\000\000\000\000\000\000\000\002\170\002\174\000\000\000\000\002z\000\000\006M\006M\006M\002\230\006M\006M\000\000\000\000\006\249\000\000\000\000\000\000\000\000\001\194\000\000\000\000\000\000\002\234\000\000\006M\000\000\000\000\000\000\006M\000\000\000\000\002\238\000\000\003\138\000\000\000\000\000\000\000\000\000\000\006M\000\000\003\210\001\174\000\000\000\000\007^\000\000\000\000\002\162\006I\000\000\003\218\006I\000\000\000\000\bf\bj\bv\000\000\000\000\005\138\000\000\006I\000\000\006I\000\000\006I\000\000\006I\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006I\005\150\005\154\000\000\000\000\000\000\006I\007\218\000\000\000\000\000\000\b~\000\000\b\130\000\000\006I\000\000\000\000\006I\000\000\000\000\000\000\000\000\006I\006I\000\238\000\000\005\158\b\146\000\000\000\000\000\000\tz\004^\000\000\000\000\000\000\000\000\000\000\006I\000\000\000\000\000\000\006I\r\141\000\000\000\000\000\000\r\141\000\000\000\000\r\141\000\000\000\000\006I\006I\006I\000\000\006I\006I\000\000\r\141\000\000\r\141\000\000\r\141\000\000\r\141\000\000\000\000\001\186\001\190\000\000\006I\000\000\000\000\000\000\006I\000\000\r\141\000\000\000\000\000\000\000\000\002\134\r\141\r\141\000\000\006I\001\194\001\234\001\214\000\000\000\000\r\141\000\000\000\000\r\141\000\000\001\226\000\000\000\000\r\141\r\141\000\238\000\000\001\242\000\000\000\000\000\000\000\000\000\000\001\230\002\138\000\000\000\000\000\000\002\150\r\141\002\162\004\014\004\026\r\141\r\145\000\000\000\000\004&\r\145\000\000\000\000\r\145\000\000\000\000\r\141\r\141\r\141\000\000\r\141\r\141\000\000\r\145\000\000\r\145\004*\r\145\000\000\r\145\000\000\000\000\007y\007y\000\000\r\141\000\000\000\000\000\000\r\141\000\000\r\145\000\000\000\000\000\000\000\000\000\000\r\145\007\218\000\000\r\141\007y\007y\007y\000\000\000\000\r\145\000\000\018\002\r\145\000\000\007y\000\000\000\000\r\145\r\145\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007y\007y\000\000\000\000\000\000\007y\r\145\007y\007y\007y\r\145\007^\000\000\000\000\007y\006a\000\000\000\000\006a\000\000\000\000\r\145\r\145\r\145\000\000\r\145\r\145\000\000\006a\000\000\006a\007y\006a\000\000\006a\000\000\000\000\r\149\r\149\000\000\r\145\000\000\000\000\000\000\r\145\000\000\006a\000\000\000\000\000\000\000\000\000\000\006a\007\218\000\000\r\145\r\149\r\149\r\149\007r\000\000\006a\000\000\000\000\006a\000\000\r\149\000\000\000\000\006a\006a\000\238\000\000\000\000\000\000\000\000\000\000\005\018\000\000\r\149\r\149\000\000\000\000\000\000\r\149\006a\r\149\r\149\r\149\006a\006e\000\000\000\000\r\149\006e\000\000\000\000\006e\000\000\000\000\006a\006a\006a\000\000\006a\006a\000\000\006e\000\000\006e\r\149\006e\000\000\006e\000\000\000\000\001\186\001\190\r&\006a\000\000\000\000\000\000\006a\000\000\006e\000\000\000\000\000\000\000\000\000\000\006e\006e\000\000\006a\001\194\001\198\001\214\000\000\000\000\006e\000\000\000\000\006e\000\000\001\226\000\000\000\000\006e\006e\006e\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\230\002\138\000\000\000\000\000\000\002\150\006e\002\162\004\014\004\026\006e\006]\000\000\000\000\004&\006]\000\000\000\000\006]\000\000\000\000\006e\006e\006e\000\000\006e\006e\000\000\006]\000\000\006]\004*\006]\000\000\006]\000\000\000\000\000\000\000\000\000\000\006e\000\000\000\000\000\000\006e\000\000\006]\000\000\000\000\000\000\000\000\000\000\006]\007\218\000\000\b\002\000\000\000\000\000\000\000\000\000\000\006]\000\000\000\000\006]\000\000\000\000\000\000\000\000\006]\006]\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006]\000\000\000\000\000\000\006]\000\000\000\000\000\000\003\205\002\170\002\174\003\205\000\000\002z\000\000\006]\006]\006]\002\230\006]\006]\003\205\000\000\007!\000\000\003\205\000\000\003\205\001\194\000\000\000\000\000\000\002\234\000\000\006]\000\000\000\000\000\000\006]\003\205\018\018\002\238\000\000\003\138\000\000\003\205\000\000\000\000\000\000\006]\000\000\003\210\001\174\000\000\003\205\000\000\000\000\003\205\002\162\000\000\000\000\003\218\003\205\003\205\003\205\bf\bj\bv\000\000\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\205\000\000\000\000\000\000\003\205\003\217\000\000\001\190\003\217\000\000\000\000\000\000\000\000\005\150\005\154\003\205\003\205\028F\003\217\003\205\003\205\000\000\003\217\b~\003\217\b\130\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\217\018r\003\205\005\158\b\146\000\000\003\217\003\205\tz\004^\000\000\000\000\000\000\002\146\000\000\003\217\000\000\000\000\003\217\003\213\000\000\001\190\003\213\003\217\003\217\003\217\000\000\000\000\000\000\000\000\000\000\000\000\003\213\000\000\000\000\000\000\003\213\000\000\003\213\003\217\003\217\000\000\000\000\004\186\000\000\000\000\000\000\000\000\000\246\000\000\003\213\002\178\000\000\000\000\003\217\003\217\003\213\000\000\003\217\003\217\000\000\031\"\000\000\002\146\000\000\003\213\000\000\003b\003\213\000\000\003\217\000\000\000\000\003\213\003\213\003\213\000\000\003\217\000\000\003n\000\000\000\000\003\217\000\000\000\000\019\186\000\000\000\000\003\217\003\213\003\213\000\000\000\000\004\186\027r\000\000\000\000\020\030\001-\000\000\000\000\001-\0206\000\000\003\213\003\213\000\000\000\000\003\213\003\213\000\000\001-\000\000\001-\000\000\001-\000\000\001-\020>\000\000\003\213\000\000\030\210\000\000\000\000\000\000\000\000\003\213\000\000\001-\000\000\000\000\003\213\020R\020\142\001-\000\000\005E\003\213\001-\000\000\000\000\000\000\000\000\001-\000\000\000\000\001-\000\000\000\000\000\000\000\000\001-\001-\000\238\000\000\024\190\000\000\000\000\000\000\000\000\000\000\001-\000\000\000\000\000\000\000\000\000\000\001-\000\000\000\000\000\000\001-\000\000\000\000\000\000\000\000\001)\000\000\000\000\001)\000\000\000\000\001-\001-\001-\000\000\001-\001-\000\000\001)\000\000\001)\000\000\001)\000\000\001)\000\000\000\000\001-\000\000\000\000\000\000\000\000\000\000\000\000\001-\000\000\001)\000\000\000\000\000\000\000\000\000\000\001)\000\000\000\000\001-\001)\000\000\000\000\000\000\000\000\001)\000\000\000\000\001)\000\000\000\000\000\000\000\000\001)\001)\000\238\000\000\000\000\000\000\001Y\000\000\012\233\001Y\001)\000\000\000\000\000\000\000\000\000\000\001)\012\233\000\000\001Y\001)\001Y\000\000\001Y\000\000\001Y\000\000\000\000\000\000\000\000\000\000\001)\001)\001)\000\000\001)\001)\001Y\000\000\000\000\000\000\000\000\000\000\001Y\012\233\000\000\000\000\001)\000\000\000\000\012\233\000\000\000\000\000\000\001)\001Y\000\000\000\000\000\000\000\000\001Y\001Y\001Y\000\000\000\000\001)\001\029\000\000\002\t\001\029\000\000\000\000\000\000\000\000\000\000\000\000\001Y\002\t\000\000\001\029\012\233\001\029\000\000\001\029\000\000\001\029\000\000\000\000\000\000\000\000\000\000\001Y\001Y\001Y\000\000\001Y\001Y\001\029\000\000\000\000\000\000\000\000\000\000\001\029\002\t\000\000\000\000\000\000\000\000\000\000\002\t\000\000\000\000\000\000\001Y\001\029\000\000\000\000\000\000\000\000\001\029\001\029\001\029\000\000\000\000\001Y\001\169\000\000\017\250\001\169\000\000\002z\000\000\000\000\000\000\000\000\001\029\000\000\000\000\001\169\002\t\000\000\000\000\001\169\000\000\001\169\000\000\000\000\000\000\000\000\000\000\001\029\001\029\001\029\000\000\001\029\001\029\001\169\000\000\000\000\000\000\000\000\000\000\001\169\000\000\000\000\000\000\000\000\000\000\017\254\000\000\000\000\001\169\000\000\001\029\001\169\000\000\000\000\000\000\000\000\001\169\001\169\000\000\018\n\000\000\001\029\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\169\000\000\000\000\000\000\001\169\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\154\001\169\001\169\000\000\000\000\001\169\001\169\002\254\002\174\000\000\000\000\002z\000\000\006\214\000\000\000\000\002\230\001\169\000\000\000\000\000\000\005\214\000\000\003\242\001\169\000\000\001\194\000\000\006\246\000\000\000\000\000\000\000\000\003\002\000\000\001\169\b\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\026f\000\000\003\014\000\000\000\000\003\026\001\174\000\000\000\000\000\000\000\000\000\000\002\162\000\000\000\000\003\234\000\000\000\000\000\000\003\238\000\000\003\246\005~\t\n\005\138\000\000\000\000\000\000\000\000\000\000\000\000\002\254\002\174\000\000\000\000\002z\005\142\006\214\000\000\000\000\002\230\000\000\000\000\000\000\000\000\005\150\005\154\000\000\005\218\024\214\001\194\000\000\006\246\000\000\000\000\000\000\000\000\003\002\000\000\000\000\b\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006z\027&\003\014\005\158\000\000\b\250\001\174\b\182\000\000\004^\000\000\000\000\002\162\000\000\000\000\003\234\000\000\000\000\000\000\003\238\000\000\003\246\000\000\t\n\005\138\000\000\000\000\000\000\000\000\000\000\000\000\002\254\002\174\000\000\000\000\002z\005\142\006\214\000\000\000\000\002\230\000\000\000\000\000\000\000\000\005\150\005\154\000\000\000\000\r\026\001\194\000\000\006\246\000\000\000\000\000\000\000\000\003\002\000\000\000\000\b\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\025n\003\014\005\158\000\000\b\250\001\174\000\000\000\000\004^\000\000\000\000\002\162\005\t\000\000\003\234\005\t\000\000\000\000\003\238\000\000\003\246\000\000\t\n\005\138\000\000\005\t\000\000\000\000\000\000\005\t\007^\005\t\000\000\000\000\005\t\005\142\000\000\005\t\000\000\000\000\000\000\000\000\000\000\005\t\005\150\005\154\000\000\005\t\r\026\005\t\000\000\005\t\000\000\005\t\000\000\000\000\000\000\000\000\005\t\000\000\000\000\005\t\005\t\000\000\000\000\005\t\005\t\002\210\025\206\000\000\005\158\005\t\007\218\000\000\000\000\005\t\004^\b2\000\000\005\t\005\t\005\t\005\t\005\t\000\000\000\000\005\t\000\000\005\t\002\210\000\238\000\000\000\000\005\t\000\000\000\000\000\000\005\t\005\t\005\t\000\000\005\t\005\t\000\000\005\t\005\t\000\000\000\000\005\t\b\165\000\000\005\t\b\165\007\138\000\000\000\000\005\t\002\210\000\000\005\t\005\t\000\000\b\165\005\t\005\t\028>\b\165\000\000\b\165\000\000\000\000\005\t\005\t\000\000\000\000\005\t\000\000\000\000\000\000\000\000\b\165\000\000\005\t\000\000\000\000\000\000\b\165\005\t\005\t\000\000\b\165\005\t\005\t\005\t\000\000\b\165\000\000\000\000\b\165\007\238\000\000\000\000\000\000\b\165\b\165\000\238\000\000\000\000\000\000\000\000\005\t\000\000\b\165\b\165\b\161\024>\000\000\b\161\000\000\b\165\000\000\000\000\000\000\b\165\000\000\000\000\000\000\b\161\000\000\000\000\000\000\b\161\000\000\b\161\b\165\b\165\b\165\000\000\b\165\b\165\000\000\000\000\000\000\000\000\000\000\b\161\000\000\000\000\000\000\000\000\b\165\b\161\000\000\000\000\000\000\b\161\000\000\b\165\000\000\000\000\b\161\000\000\000\000\b\161\000\000\000\000\000\000\000\000\b\161\b\161\000\238\000\000\000\000\000\000\000\000\000\000\000\000\b\161\b\161\003\205\000\000\000\000\003\205\000\000\b\161\000\000\000\000\000\000\b\161\000\000\000\000\000\000\003\205\000\000\001\186\001\190\003\205\000\000\003\205\b\161\b\161\b\161\000\000\b\161\b\161\000\000\000\000\000\000\000\000\000\000\003\205\018\018\000\000\001\194\001\234\b\161\003\205\000\000\000\000\000\000\000\000\000\000\b\161\000\000\000\000\003\205\000\000\000\000\003\205\000\000\000\000\000\000\000\000\003\205\003\205\003\205\001\230\002\154\000\000\000\000\000\000\002\150\000\000\002\162\004\014\004\026\000\000\000\000\000\000\003\205\004&\004\241\004\241\003\205\000\000\004\241\000\000\000\000\000\000\000\000\004\241\000\000\000\000\000\000\003\205\003\205\004\241\004*\003\205\003\205\004\241\005\129\000\000\000\000\000\000\000\000\000\000\004\241\026\030\000\000\003\205\0266\000\000\000\000\000\000\000\000\018r\003\205\000\000\028\194\004\241\000\000\003\205\004\241\004\241\000\000\000\000\000\000\003\205\000\000\004\241\000\000\000\000\004\241\000\000\000\000\000\238\004\241\000\000\004\241\004\241\000\000\004\241\000\000\000\000\000\000\000\000\000\000\000\000\002\254\002\174\000\000\000\000\002z\004\241\000\000\000\000\000\000\002\230\000\000\000\000\000\000\000\000\004\241\004\241\t\217\000\000\000\000\001\194\000\000\000\000\000\000\000\000\000\000\000\000\003\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\003\014\004\241\000\000\003\026\001\174\000\000\000\000\004\241\003\205\000\000\002\162\003\205\000\000\003\234\000\000\000\000\000\000\003\238\000\000\003\246\005~\003\205\005\138\000\000\000\000\003\205\000\000\003\205\000\000\000\000\000\000\000\000\000\000\000\000\005\142\000\000\000\000\000\000\000\000\003\205\018\018\000\000\000\000\005\150\005\154\003\205\005\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\205\012\225\000\000\003\205\012\225\000\000\000\000\000\000\003\205\003\205\003\205\000\000\000\000\000\000\012\225\005\158\000\000\t\217\012\225\000\000\012\225\004^\000\000\000\000\003\205\000\000\005\173\000\000\003\205\000\000\000\000\000\000\012\225\000\000\000\000\000\000\000\000\000\000\012\225\003\205\003\205\028v\000\000\003\205\003\205\000\000\000\000\012\225\000\000\000\000\012\225\000\000\000\000\000\000\000\000\012\225\012\225\000\000\000\000\000\000\000\000\018r\003\205\000\000\000\000\000\000\000\000\003\205\000\000\000\000\000\000\012\225\000\000\002\254\002\174\012\225\000\000\002z\000\000\000\000\000\000\000\000\002\230\000\000\000\000\000\000\012\225\012\225\002r\006\142\012\225\012\225\001\194\000\000\000\000\000\000\000\000\000\000\000\000\003\002\000\000\000\000\012\225\000\000\000\000\000\000\0292\000\000\000\000\012\225\000\000\000\000\003\014\000\000\000\000\003\026\001\174\000\000\000\000\000\000\012\225\000\000\002\162\006\001\000\000\003\234\006\001\000\000\000\000\003\238\000\000\003\246\005~\000\000\005\138\000\000\006\001\000\000\000\000\000\000\006\001\000\000\006\001\000\000\000\000\000\000\005\142\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\001\005\150\005\154\000\000\005\218\000\000\006\001\000\000\000\000\000\000\000\000\000\000\b2\000\000\000\000\006\001\000\000\000\000\006\001\006\005\000\000\000\000\006\005\006\001\006\001\000\238\000\000\005\158\000\000\006\198\000\000\000\000\006\005\004^\000\000\000\000\006\005\000\000\006\005\006\001\006\001\000\000\000\000\006\001\000\000\000\000\000\000\000\000\000\000\000\000\006\005\000\000\000\000\000\000\006\001\006\001\006\005\000\000\006\001\006\001\000\000\000\000\b2\000\000\000\000\006\005\003\205\000\000\006\005\003\205\000\000\000\000\000\000\006\005\006\005\000\238\000\000\006\001\000\000\003\205\000\000\000\000\000\000\003\205\000\000\003\205\000\000\000\000\006\001\006\005\006\005\000\000\000\000\006\005\000\000\000\000\000\000\003\205\018\018\000\000\000\000\000\000\000\000\003\205\006\005\006\005\000\000\000\000\006\005\006\005\000\000\006\169\003\205\000\000\006\169\003\205\000\000\000\000\000\000\000\000\003\205\003\205\003\205\000\000\006\169\000\000\000\000\006\005\006\169\000\000\006\169\000\000\000\000\000\000\000\000\000\000\003\205\000\000\006\005\000\000\003\205\000\000\006\169\000\000\000\000\000\000\000\000\000\000\006\169\000\000\000\000\003\205\003\205\020\158\000\000\003\205\003\205\006\169\000\000\000\000\006\169\000\000\000\000\000\000\000\000\006\169\006\169\000\238\000\000\000\000\000\000\000\000\000\000\018r\003\205\000\000\000\000\000\000\000\000\000\000\000\000\006\169\000\000\000\000\000\000\006\169\000\000\000\000\000\000\012\161\000\000\002\174\012\161\000\000\030\218\000\000\006\169\006\169\024b\030\222\006\169\006\169\012\161\000\000\000\000\000\000\000\000\000\000\012\161\000\000\000\000\000\000\006\169\000\000\000\000\000\000\000\000\000\000\000\000\006\169\012\161\000\000\000\000\000\000\000\000\000\000\012\161\002\254\002\174\000\000\006\169\002z\001\002\001\174\000\000\012\161\002\230\000\000\012\161\000\000\000\000\006\253\000\000\012\161\000\000\000\000\001\194\000\000\000\000\000\000\000\000\030\226\000\000\003\002\000\000\000\000\000\000\000\000\000\000\012\161\000\000\000\000\000\000\012\161\000\000\000\000\003\014\000\000\000\000\003\026\001\174\000\000\000\000\030\230\012\161\012\161\002\162\000\000\012\161\003\234\000\000\000\000\000\000\003\238\000\000\003\246\005~\000\000\005\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\161\000\000\000\000\005\142\000\000\000\000\b\213\b\213\000\000\000\000\b\213\000\000\005\150\005\154\000\000\b\213\000\000\000\000\000\000\000\000\000\000\018\186\000\000\000\000\000\000\b\213\000\000\000\000\000\000\000\000\000\000\000\000\b\213\007^\000\000\000\000\000\000\007\181\005\158\000\000\007\181\000\000\000\000\000\000\004^\b\213\000\000\000\000\b\213\b\213\007\181\000\000\000\000\000\000\007\181\b\213\007\181\000\000\b\213\000\000\000\000\000\000\b\213\001\173\b\213\b\213\001\173\b\213\007\181\000\000\000\000\000\000\000\000\000\000\007\181\007\218\001\173\000\000\000\000\b\213\001\173\000\000\001\173\007\181\000\000\000\000\007\181\000\000\b\213\b\213\000\000\007\181\007\181\000\238\001\173\000\000\000\000\000\000\000\000\000\000\001\173\000\000\000\000\000\000\000\000\000\000\000\000\007\181\000\000\001\173\000\000\007\181\001\173\000\000\b\213\000\000\000\000\001\173\001\173\000\000\b\213\000\000\007\181\007\181\000\000\000\000\007\181\007\181\000\000\000\000\000\000\000\000\000\000\001\173\000\000\000\000\000\000\001\173\006\173\000\000\000\000\006\173\000\000\000\000\000\000\007\181\000\000\000\000\001\173\001\173\000\000\006\173\001\173\001\173\000\000\006\173\000\000\006\173\000\000\000\000\000\000\000\000\000\000\000\000\001\173\000\000\000\000\000\000\000\000\006\173\000\000\001\173\000\000\000\000\000\000\006\173\024>\000\000\000\000\000\000\000\000\000\000\001\173\000\000\006\173\000\000\000\000\006\173\012\225\000\000\000\000\012\225\006\173\006\173\000\238\000\000\000\000\000\000\001\186\001\190\000\000\012\225\000\000\000\000\000\000\012\225\000\000\012\225\006\173\000\000\000\000\000\000\006\173\005\173\000\000\000\000\000\000\001\194\001\198\012\225\000\000\000\000\000\000\006\173\006\173\012\225\000\000\006\173\006\173\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\225\000\000\006\173\001\230\002\146\012\225\012\225\000\000\002\150\006\173\002\162\004\014\004\026\000\000\000\000\000\000\000\000\004&\000\000\018\022\006\173\012\225\000\000\000\000\001\186\002v\000\000\000\000\002z\000\000\000\000\000\000\000\000\000\000\004*\000\000\012\225\012\225\002r\000\000\012\225\012\225\000\000\001\194\001\234\001\214\002~\000\000\000\000\000\000\000\000\000\000\012\225\001\226\000\000\000\000\029j\000\000\000\000\012\225\000\000\000\000\000\000\000\000\000\000\000\000\002\130\002\138\000\000\000\000\012\225\002\150\000\000\002\162\004\014\004\026\000\000\000\000\000\000\000\000\024\022\000\000\024\026\001E\000\000\000\000\001E\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001E\004*\001E\000\000\001E\000\000\001E\000\000\000\000\000\000\000\000\005\154\000\000\000\209\000\000\000\000\000\209\000\000\001E\000\000\000\000\000\000\000\000\024&\001E\000\000\000\209\000\000\000\000\000\000\000\209\000\000\000\209\000\000\000\000\000\000\001E\000\000\000\000\000\000\024*\001E\001E\000\238\000\209\000\000\000\000\000\000\000\000\000\000\000\209\000\000\000\000\000\000\000\000\000\000\000\000\001E\000\000\000\209\000\000\000\000\000\209\000\000\000\000\000\000\000\000\000\209\000\209\000\238\000\000\000\000\001E\001E\001E\000\000\001E\001E\000\000\000\000\000\000\000\000\000\000\000\209\000\000\000\000\000\000\000\209\000\213\000\000\000\000\000\213\000\000\000\000\000\000\001E\000\000\000\000\000\209\000\209\000\000\000\213\000\209\000\209\000\000\000\213\001E\000\213\000\000\000\000\001\186\002v\000\000\000\000\002z\000\000\000\000\000\000\000\000\000\213\000\000\000\209\000\000\000\000\000\000\000\213\000\000\000\000\000\000\001\194\001\234\001\214\000\209\000\000\000\213\000\000\000\000\000\213\000\000\001\226\000\000\000\000\000\213\000\213\000\238\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\130\002\138\000\000\000\000\000\000\002\150\000\213\002\162\004\014\004\026\000\213\000\000\000\000\000\000\024\022\000\000\029\022\007\177\000\000\000\000\007\177\000\213\000\213\000\000\000\000\000\213\000\213\000\000\000\000\000\000\007\177\004*\000\000\000\000\007\177\000\000\007\177\000\000\000\000\000\000\000\000\005\154\000\000\000\000\000\213\000\000\000\000\000\000\007\177\000\000\000\000\000\000\000\000\029\"\007\177\000\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\177\006\161\000\000\007\177\006\161\000\000\000\000\024*\007\177\007\177\000\000\020z\000\000\000\000\006\161\000\000\000\000\000\000\006\161\000\000\006\161\000\000\000\000\000\000\007\177\000\000\000\000\000\000\007\177\000\000\000\000\000\000\006\161\000\000\000\000\000\000\000\000\000\000\006\161\007\177\007\177\019\206\007^\007\177\007\177\000\000\006\r\006\161\000\000\006\r\006\161\000\000\000\000\000\000\000\000\006\161\006\161\000\000\000\000\006\r\000\000\000\000\007\177\006\r\000\000\006\r\000\000\000\000\000\000\000\000\000\000\006\161\000\000\000\000\000\000\006\161\000\000\006\r\007}\007}\000\000\000\000\000\000\006\r\007\218\000\000\006\161\006\161\000\000\000\000\006\161\006\161\000\000\012Q\004\030\006\r\012Q\007}\007}\007}\006\r\006\r\000\238\000\000\000\000\000\000\012Q\007}\000\000\006\161\012Q\000\000\012Q\000\000\000\000\000\000\006\r\000\000\000\000\000\000\007}\007}\000\000\000\000\012Q\007}\000\000\007}\007}\007}\012Q\006\r\006\r\000\000\007}\006\r\006\r\000\000\000\000\012Q\004\225\000\000\012Q\004\225\000\000\000\000\000\000\012Q\000\000\000\000\000\000\007}\000\000\004\225\006\r\000\000\000\000\004\225\000\000\004\225\000\000\000\000\000\000\012Q\n\182\000\000\000\000\012Q\000\000\000\000\000\000\004\225\000\000\000\000\000\000\000\000\000\000\004\225\012Q\012Q\000\000\000\000\012Q\012Q\000\000\005\t\004\225\000\000\005\t\004\225\004\018\000\000\007}\000\000\004\225\000\000\000\000\000\000\005\t\000\000\000\000\012Q\005\t\000\000\005\t\000\000\000\000\000\000\000\000\000\000\004\225\000\000\r\014\000\000\004\225\000\000\005\t\000\000\000\000\000\000\000\000\000\000\005\t\000\000\000\000\004\225\004\225\000\000\0042\004\225\004\225\000\000\007\177\000\000\005\t\007\177\000\000\000\000\000\000\005\t\002\210\000\000\000\000\000\000\000\000\007\177\000\000\000\000\004\225\007\177\000\000\007\177\000\000\000\000\000\000\005\t\000\000\000\000\000\000\019\246\000\000\000\000\000\000\007\177\000\000\000\000\000\000\000\000\000\000\007\177\005\t\005\t\000\000\000\000\005\t\005\t\000\000\004\217\000\000\000\000\004\217\007\177\004>\000\000\000\000\000\000\007\177\007\177\000\000\000\000\004\217\000\000\000\000\005\t\004\217\000\000\004\217\000\000\000\000\000\000\000\000\000\000\007\177\000\000\000\000\000\000\000\000\000\000\004\217\000\000\000\000\000\000\000\000\000\000\004\217\000\000\000\000\007\177\007\177\019\206\000\000\007\177\007\177\004\217\000\000\000\000\004\217\000\000\000\000\000\000\000\000\004\217\000\000\004\249\000\000\000\000\004\249\021\014\000\000\000\000\007\177\000\000\000\000\000\000\000\000\000\000\004\249\004\217\000\000\000\000\004\249\004\217\004\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\217\004\217\004\249\000\000\004\217\004\217\000\000\000\000\004\249\000\000\000\000\000\000\000\000\004\201\000\000\000\000\004\201\004\249\000\000\000\000\004\249\000\000\000\000\004\217\000\000\004\249\004\201\000\000\000\000\000\000\004\201\000\000\004\201\000\000\022\246\000\000\000\000\000\000\000\000\000\000\000\000\004\249\000\000\000\000\004\201\004\249\000\000\000\000\000\000\000\000\004\201\000\000\000\000\b=\000\000\000\000\004\249\004\249\000\000\004\201\004\249\004\249\004\201\000\000\000\000\000\000\000\000\004\201\000\000\b=\b=\000\000\b=\b=\000\000\001\186\001\190\000\000\000\000\004\249\000\000\000\000\000\000\004\201\000\000\000\000\000\000\004\201\000\000\000\000\023\218\003\242\000\000\b=\001\194\001\234\001\214\000\000\004\201\004\201\000\000\000\000\004\201\004\201\001\226\000\000\000\000\000\000\000\000\000\000\000\246\b=\000\000\002\178\000\000\000\000\000\000\001\230\002\138\000\000\bI\004\201\002\150\003^\002\162\004\014\004\026\005\029\000\000\003b\000\000\004&\027F\b-\000\000\000\000\bI\bI\000\000\bI\bI\003n\b=\000\000\b=\000\000\000\000\019\186\004*\b-\b-\000\000\b-\b-\000\000\000\000\027r\000\000\005\242\020\030\bI\b=\b=\000\000\0206\bM\b=\000\000\b=\000\000\000\000\000\000\b=\b-\000\000\000\000\000\000\000\000\000\238\000\000\020>\bM\bM\000\000\bM\bM\000\000\004Z\000\000\004^\000\000\b-\000\000\000\000\000\000\020R\020\142\bA\000\000\005\029\005\029\000\000\000\000\000\000\000\000\bM\000\000\000\000\000\000\bI\000\000\bI\000\000\bA\bA\000\000\bA\bA\024\190\000\000\000\000\000\000\b-\000\238\b-\bI\000\000\000\000\005\250\bI\000\000\000\000\000\000\bI\000\000\bI\000\000\bA\b-\bI\000\000\005\250\b-\000\000\000\000\000\000\b-\000\000\b-\000\000\000\000\000\000\b-\000\000\bM\000\238\bM\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\bM\000\000\000\000\005\250\bM\001\186\001\190\025r\bM\000\000\bM\000\000\000\000\000\000\bM\000\000\bA\000\000\bA\000\000\000\000\000\000\000\000\000\000\001\194\001\198\001\214\000\000\000\000\000\000\000\000\000\000\006N\000\000\001\226\005\250\bA\000\000\000\000\000\000\bA\000\000\bA\001\186\001\190\025\210\bA\001\230\002\138\000\000\000\000\000\000\002\150\000\000\002\162\004\014\004\026\000\000\000\000\000\000\000\000\004&\001\194\001\198\001\214\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\226\000\000\000\000\000\000\000\000\000\000\004*\000\000\000\000\000\000\000\000\000\000\000\000\001\230\002\138\000\000\000\000\000\000\002\150\000\000\002\162\004\014\004\026\000\000\000\000\000\000\000\000\004&\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004*")) and lhs = - (8, "\014\r\012\011\n\t\b\007\006\005\004\003\002\001\000\225\225\224\224\223\222\222\221\221\221\221\221\221\221\221\221\221\221\221\221\221\221\221\221\221\221\221\220\220\219\218\218\218\218\218\218\218\218\217\217\217\217\217\217\217\217\216\216\216\215\215\214\213\213\213\212\212\211\211\211\211\211\211\210\210\210\210\210\210\210\209\209\209\209\209\208\208\208\208\207\206\205\205\205\205\204\204\204\204\203\203\203\202\202\202\202\201\200\200\200\199\199\198\198\197\197\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\196\195\195\194\194\193\192\191\190\190\189\189\188\188\188\188\187\187\187\187\186\186\185\184\184\184\184\184\184\183\182\181\181\180\180\179\179\178\177\177\176\175\175\174\173\172\172\172\171\171\170\169\169\169\169\169\169\168\168\168\168\168\168\168\168\167\167\166\166\166\166\166\166\165\165\164\164\164\163\163\162\162\162\162\161\161\160\160\159\159\158\158\157\157\156\156\155\155\154\154\153\153\152\152\151\151\151\150\150\150\150\149\149\148\148\147\147\146\146\146\146\146\145\145\145\145\144\143\143\142\142\142\141\141\141\141\141\141\141\140\140\140\140\140\140\140\139\139\138\138\137\137\137\137\137\137\136\136\135\135\134\134\133\133\132\132\131\130\130\130\129\129\128\128\128\128\128\128\128\128\128\127\127~}}}}}}}}}|{zyyxxxxxwvvuuttttttttttttttssrrqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqppoonnmmllkkjjiihhggffeeeeeedcba`_^]\\[ZYYYYYYYXXWWVVVVVUUUUUUTTSSSSSRRQQPONNMMMMMLLKKJJJIIIIIIHHHGGFFEEDDCCBBBAA@@??>>==<<;;::99887776665554443333210000000000000000000/////....---------------------------------------------,,++++++++++++++++***************************************************))(((''&&&&&&&&&&&&&&&&&%%$$#######\"\"\"\"!! \031\031\030\029\028\028\028\027\027\026\026\026\026\026\026\026\026\026\026\025\025\024\023\023\022\021\021\021\021\021\020\019\019\018\018\018\017\017\017\016\016\016\016\016\016\015\015") + (8, "\014\r\012\011\n\t\b\007\006\005\004\003\002\001\000\232\232\231\231\230\229\229\228\228\228\228\228\228\228\228\228\228\227\227\226\225\224\224\224\224\224\224\224\224\223\223\223\223\223\223\223\223\222\222\222\221\221\220\219\219\219\218\218\217\217\217\217\217\217\216\216\216\216\216\216\216\215\215\215\215\215\214\214\214\214\213\212\211\211\211\211\210\210\210\210\209\209\209\208\208\208\208\207\206\206\206\205\205\204\204\203\203\203\202\202\202\202\202\202\202\202\202\201\201\200\200\199\199\198\197\196\195\194\194\193\193\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\192\191\191\190\189\189\189\189\188\188\188\188\187\187\186\185\185\185\185\185\185\184\183\182\182\181\181\180\180\179\178\178\177\176\176\175\174\173\173\173\172\172\171\170\170\170\170\170\170\169\169\169\169\169\169\169\169\168\168\167\167\167\167\167\167\166\166\165\165\165\164\164\163\163\163\163\162\162\161\161\160\160\159\159\158\158\157\157\156\156\155\155\154\154\153\153\152\152\152\151\151\151\151\150\150\149\149\148\148\147\147\147\147\147\146\146\146\146\145\145\145\144\144\144\144\144\144\144\143\143\143\143\143\143\143\142\142\141\141\140\140\140\140\140\140\139\139\138\138\137\137\136\136\135\135\134\133\133\133\132\132\131\131\131\131\131\131\131\131\131\130\130\129\128\128\128\128\128\128\128\128\128\128\127~}||{{{{{zyyxxwwwwwwwwwwwwwwvvuuttsssssssssssssssssssssssssssssssrrqqppoonnmmlllkkjjiihhggffffffffffedcba`_^]\\[ZZZZZZZYYXXWWWWWVVVVVVUUTTTTTSSRRQPOONNNNNMMLLKKKJJJJJJIIIHHGGFFEEDDCCBBBAA@@??>>==<<;;::::::998877777766655544433210000000000000000000/////....----------------------------------------------,,++++++++++++++++***************************************************))((''&&&&&&&&&&&&&&&&%%$$#######\"\"\"\"!! \031\031\030\029\028\028\028\027\027\026\026\026\026\026\026\026\026\026\026\025\025\024\023\023\022\021\021\021\021\021\020\019\019\018\018\018\017\017\017\016\016\016\016\016\016\015\015") and goto = - ((16, "\000)\001Q\000S\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\000\000\000\000\000_\000<\000\026\000\251\0001\t\152\000\000\000\000\000\233\000-\t\248\000\181\001\204\nj\000\000\000\000\000\000E\006\000=\003\012\000\025:>\000\000\000\000\000\000\000\000\000\000\000\000\000\00072\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000F\003<\000\210\000\000\000\000\000\000\000\000\000\221\000\000\004\1581\226\000d\004\178\000@\001H\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\244\000\000\000\000\000\000\000\000\000\000\001@\000\000\000\000\000\000\001\146\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000F\018\000\000\000\000\002>\000\000\000\000\000\000\000\000\000\000\000\000\000\000/\022\002B\000\000\002V\004\180\001H\000\000\000\000\005t\000k\000\000\005\168\0060\002\166\005\174\000 \000\000\000\000\000\000\000\228\000\000\000\000\002p\000\000\000\000\000\000\000\000\004\016\000\000\003<\000\000\000\000\000\000\000\000\000\000\000>\000\000\003\236\004|\000\128\000\000\003\242/\022\000\000\006\204\000\000\001\188\000\0000\\\000\194\001|\007\174\000\000\000\000\000\000\003B\003\132\005\252\001(\003\138\006\140$\146\003\222\006\144\000\243\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007n\000\000\000\000\000\000\004H\007x\n\166\004\154\007z\n\200\b\154E\006\011v\000\000$\232\004\250\b6\005\246\000\0004\2207\1588$\000\000\000u\000\000\000\000\000\000\005\208>,\006\b\000\000:\138\006t\000\000:\222A\218\000\143\000\000\000\255\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000;\016\005\244\000\000\000\000\000\000\b\194\000\000\001\216\000\000\000\000\004\020\001j\000\000\000\000\011\b\000\000\t\244\000\000\004\020\002\206\004\020\000\000\000\000\000\000\000\000\000\000B \000\000\bf\007\152\000\000:r\t\b\002\246\000\000\000\000\000\000\007B\000\000\000\000\000\000\000\000\007<\000\000\000\000\000\000\000\000\000\000;\146\000\000\000\000\000\000\000\000\000\000\000\000\001\024\b\012\000\000\000\000\000\000\007<\bH;\216\007\248\t.\012\026\000\000\005*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\236\000\000\000\000\000\000\000\000\t0f\007\232\000T\000\000\007\232\007\232\000\000\000\000\007\232\000\0008$\000\000\000\000\000\000\007\2328>\000\000\000\000\007\232\000\000\006\004\t\014\000\000\000\000\000\000\000\000\000\000\000\000>\\\000\000\b\162\000\000J2\007<\000\000\000\000\000\000\000\000\b\188\tF\011\1744\238B\254\t\132\000\000\004n\007\232Jt\007<\tl\000\000\000\000\000\000\000\00072\t\222\000\0008bH\206\000\000\012b\tV\t\138\t\158\t<\007\214\t\170\001\132\nR\000\000\000\000\001J\002\184\t\182\002\160\t\234\000\000\000\000\002\228\000\000\0024\000$\002\212\000\019\011T\000\000\000\0009\000\000\000P\138\n\248\000\000J\154\007\154\000\000KD%\156\n\190\t\184KR\n\204\t\232\rf\n\208\t\242\r\196\n\224\t\244\00268\170\007\232\014\026\n\248\n\002F\25472\011\156\000\000C\024\014r\011\028\n\018?f\007\232\014\200\011$\n\022?\172\007\232\015&K\140\000\000\000\000\000\000\000\000\000\000\001N\b\240\000\000\000\000\000\000\011D\n \t\194\001\172\014\"\0024\000\000\000\000\000\0004\238\000\000K\150\007<\015|\011R\nXK\154\000\000K\180\000\000\000\000\015\212%\244\000\"\000\000\000\000\012\172K\186\007<3\028\007\007L\014\148\000\000\000\000\000(\0046\n\198\000\000\017\168\0024\n\246\000\000\005`\000\000\014J\011\238\017\216\007\190\000\000\014T\011\242\tB\r&\014h\014r\012\028\016\000\000\000\014\174\004\178\000\000\000\000\000\000\000\000\002\n\012B\014\142M\022\007<\000\000\004X\012T\015J\000\000\000\000\000\000\000\000\000\000\000\000M&\b\218\000\000\012Z\015\164\000\000\000\000\000\000\000\000\000\000\000\000G4\011\030\000\000\012j\005\168\000\000\012\128\012\132\004\180\000\000\006\026Hl\000\000\006\140\000\000M6\007<\007<\000\000\000\000\tP\000\000\005\146\000\000\007\254\tP\tP\000\000\012\152I\n\007\022\000\000\012\216\000\000M\244A \007<\000\000N4\014:\000\000ND\000\000\000\000\000\000\tP\000\000\000\000\012\180\015t\012\214\016\170\015Z\000\000\000\000NV\012\248\015\154\000\000\000\000\000\0003V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\002\000\000\015\168\r\b\006\162\000\000\016\178\016j\r&\015\202\000\000\000\000\015\208\r\014\006\186\000\000\000\000/&\016\132\r0\015\232\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007<\015\150\rL\016\250\015\166\000\000-@\000\223\rT\015z\007D\000\178\rZ\0168\000\000\016\236\018\238\000\000\000\000\019L\000\000\r\134\000\000\003l\000\000\000\000\000\000\000\000\000\000\000\000Nl\007<\000\000\016\238\019\162\000\000\000\000\019\250\000\000\000c\rd\016\150\000\000C4GX\016P\000\000N\184\007<\020P\000\000\000\000\020\174\000\000\000\000\000\0009$\000\000\021\004\000\000\000\000\000\000\r\184\000\000\004\136\000\000\000\000\000\000\000\000\000\000\000\000Gt\000\000\000\000CrH.\016Z\000\000N\254\007<\021\\\000\000\000\000\021\178\000\000\000\000\r~\022\016\r\194\000\000\r\138\r\144\002~\005\180\r\164\bJ\r\206\016\1845x\r\232\000\000\r\222\014\014\n.\000\000\007\nI0\000\000\000]\000\000\014\020C\128C\184\011\152\015\150\012\128\000\000H\002N\158\000\000\000\000I\212\000\000\000\000\000\000\006p\000\000\000\000\006p\000\000\000\000\006p\nH\000\000\012\250\006p\016\1985\170\014>\000\000\006p\000\000OL\000\000\000\000\006p\000\000\000\000\014f\000\000\014\\\n\164\014l\000\000\014XIB\014\234\000\000\000\000\000\000\014\248\000\000\000\000\b\150\000\000\006pO\154\000\000\015\190\006pD\134\000\000\015\016\0160\014j\017R\015\254\000\000D\204\015\026\016>\000\000\000\000\000\000C\240\tV\014\130\016\2345\228\015\"\000\000\000\000\000\000\000\000\000\000\000\000\0116\000\000\000\000\011B\000\000\0158\000\000\016R\000\000\000\000\000\000\000\000\015>D\000\000\000\000\000\000\000\0116\000\000\011B\000\000\000\000\000\000\000\000\000\000\011N\022f\000\000\000\000\022\190\000\000\000\000\000\000\000\000\023\020\000\000\000\000\011N\023r\000\000\023\200\000\000\000\000\024 \000\000\000\000\000\000\000\000\024v\000\000\000\000/\190\011N\024\212\000\000\000\0000,\011N\025*\000\000\000\0000x\011N\007\138\025\130\000\000\000\0000\202\011N\025\216\000\000\000\0001r\011N\0266\000\000\000\0001\174\011N\000\000\000\000\026\140\000\000\000\0002\016\011N\026\228\000\000\000\0002h\011N\027:\000\000\000\0003\"\011N\000\0003n\011NI\212\011N\000\000\000\000\027\152\000\000\000\000\027\238\000\000\000\000\000\000\011`\028F\000\000\000\000\028\156\000\0009r\000\000\000\000K\140\000\000\000\000\028\250\000\000\000\000\000\000\029P\000\000\000\000\000\000\017\028\000\000\000\000A|\000\000\004\136\000\000\003:\000\000\016\182\000\000\b2\000\000\000\000\000\000\000\000\000\000\001N\000\000\000\000\016\016\000\000\000\000\029\168\000\000\029\254\000\000\000\000\000\000\030\\\000\000\000\000\030\178\016\020\031\n\000\000\031`\000\000\000\000\000\00072\016\182\000\000EL\007&\004\020\031\190\000\000EV\000\000\000\000\000\000E\136\000\000\000\000 \020\000\000 l\000\000\000\000\000\000\000\0009\220\000\000\000\000\000\0003\144\011N3\220\011N\000\000\000\000\000\000\000\000\011N\000\000\000\000\000\000\000\000\011N\000\000\017D\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\174\012X\001\172 \194\000\000\016.\014\182\016\184\011\236\000\000! \000\000\016:\014\188\t\236\016V\014\198\000\000!v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0003\028\016\220\000\000O\204\007\003\006\005M\003\169\000\234\002\139\004\021\002\149\002\243\001\021\004\022\003\173\000\222\002\155\000\225\001\135\002\141\001\021\005N\005W\002\243\001\015\0057\001{\002N\002O\001c\001\021\001\"\005I\003j\003A\003C\002\243\005K\001l\002\157\001#\000\231\002n\0058\002\030\006\161\005?\001\135\005M\006\006\002o\002\139\0034\002\149\000\227\005@\006t\000\231\000\232\002\155\004[\001\135\002\141\002\134\005N\004\254\004\016\006\128\005d\001\015\001\029\000\231\001\002\001\030\003\r\001\021\001\"\003w\003x\000\234\002\243\000\234\002\157\003&\005A\001\015\001#\004\242\004\\\004~\004]\001\021\001\"\002\243\003\128\006s\003\187\001 \003\129\003_\005\030\001}\001\021\003}\003A\003C\0019\005r\003\199\001~\002\243\001\135\001j\001,\007(\002O\001c\004\244\005\147\004^\005B\000\231\001\002\005\210\002\136\0007\002\021\005 \000\235\005C\001@\001#\004\245\000\240\000\243\006\241\002R\004\252\002\138\000\231\006\180\005\003\001(\005\"\001\015\002N\002O\001c\005U\002\145\001\021\001\024\003P\002\"\004_\006w\002 \005\164\005\243\000\231\002n\002\243\002\031\004`\004a\003\216\004b\001E\002o\005#\005W\001T\001\015\001\029\006Y\001\248\001\030\001\015\001\021\001\"\005I\002\134\003^\001\021\001\024\005K\002\243\001\165\002N\002O\001c\004\127\000\234\002N\002O\001c\005M\000\234\000\234\002\139\001 \002\149\000\227\002n\002\243\000\231\001\002\002\155\002n\001\135\002\141\002o\005N\002\021\002\243\004d\002o\005\188\006\140\002!\004f\004p\007\000\007)\002\134\002\138\000\231\001<\000\251\002\134\002\157\004{\001\248\003v\001#\002\243\000\146\001Z\004\128\004\020\002\022\005\205\002\136\002 \001\163\001(\000\231\004|\001q\006\167\006\168\004\021\001C\001z\002R\004\027\002\138\000\231\003\140\006\169\006\170\001,\002\243\001\131\001F\001\130\002\142\002\145\007\002\005$\006\171\003_\002N\002O\001c\001\015\003\155\001\015\003\159\000\146\006\141\001\021\001\"\001\021\001\024\002\136\003\158\002n\002\146\0034\002\136\001\169\000\234\0034\002\243\002o\005 \002R\001\180\002\138\000\231\006\211\002R\004\224\002\138\000\231\002!\003\249\002\134\002\142\002\145\001\185\005\"\0067\002\142\002\145\000\234\002\139\002\243\002\149\002N\002O\001c\002\243\001\199\002\155\001\029\001\135\002\141\001\030\001/\002\146\001\196\001A\003\170\002n\002\146\001#\005#\004\020\003\133\003A\003C\002o\006\149\003A\003C\001\225\002\157\006\204\002\003\004\021\001[\001 \001r\0044\002\134\001\249\006\199\001\211\002\139\001\253\002\149\001\021\001,\002\139\004\029\002\149\002\155\002\136\001\135\002\141\002\021\002\155\001E\001\135\002\141\002N\002O\001c\001\015\002R\001\015\002\138\000\231\005 \001\021\001\"\001\021\001\"\004-\002\157\002n\002\142\002\145\0045\002\157\000\234\001(\002[\002o\005\"\002 \001\202\001\254\000\231\006\201\002N\002O\001c\003\220\003_\005:\002\134\001\213\002\146\000\234\002\136\000\234\001\255\001\220\002.\002n\000\234\002N\002O\001c\005#\001\015\002R\002o\002\138\000\231\004\023\001\021\001\"\006`\003K\006\031\002n\000\231\002\142\002\145\002\134\002\139\0021\002\149\002o\001\210\002\021\0024\0027\002\155\006]\001\135\002\141\004\232\004\023\002=\000\231\002\134\006\177\004\023\002\146\001\029\002!\002E\001)\002J\005\005\001\216\002\243\000\231\002Z\002\136\002\157\002\251\001\222\000\234\002 \002\243\002\243\000\231\001+\000\234\000\234\002R\001\235\002\138\000\231\001#\001 \002\139\005\024\002\149\006.\003_\001\237\002\142\002\145\002\155\002h\001\135\002\141\002\136\002\243\001\252\002\205\006\173\000\234\001\135\002N\002O\001c\000\234\000\234\002R\001,\002\138\000\231\002\146\002\136\000\234\002\157\002\238\002\243\002n\002\247\002\142\002\145\000\234\002\021\000\234\002R\002o\002\138\000\231\000\234\003\003\002N\002O\001c\002!\003\174\006N\002\142\002\145\002\134\003\020\002\139\002\146\002\149\003\188\003\205\002n\006\159\003_\002\155\002\255\001\135\002\141\002 \002o\001\015\000\231\000\234\001\015\002\146\0066\001\021\001\"\000\234\001\021\001\"\002\r\002\134\006\026\003\209\003\025\002\139\002\157\002\149\003*\003;\006\022\003=\002\021\002\155\000\234\001\135\002\141\000\234\002-\003O\001b\001c\002\139\004\004\002\149\0020\003]\0023\000\234\004\254\002\155\002\243\001\135\002\141\002\136\0026\002\157\003c\000\234\003\021\001d\001e\002 \001f\001g\000\231\002R\002<\002\138\000\231\002!\003p\002@\002\157\001#\002N\002O\001c\002\142\002\145\003\131\001\029\002\136\000\227\001\030\002D\000\231\000\232\000\234\002I\002n\003\168\000\234\000\234\002R\000\234\002\138\000\231\002o\001\225\002\146\001,\002\028\000\234\0063\002Y\002\142\002\145\001 \001\249\000\234\002\134\002g\001\253\003\172\001\021\004\242\003\178\002N\002O\001c\000\234\002y\004$\006(\002!\005E\003\184\002\146\002\139\003\195\005i\005H\002n\002\154\000\234\001k\002\155\002\243\001\135\002\141\002o\001\029\002\222\000\234\004@\004\244\006\030\001l\002\021\003\214\000\231\003\219\001(\002\134\000\234\001\254\002\139\002\246\002\149\002\157\004\245\002N\002O\001c\002\155\004\252\001\135\002\141\001 \005\000\001\255\002\136\003\224\002\243\002\237\006!\002n\000\234\002 \003\b\000\234\000\231\001\015\002R\002o\002\138\000\231\002\157\001\021\001\"\000\234\003\234\002\239\000\234\006\028\002\142\002\145\002\134\000\227\002\242\003\240\000\231\000\232\003\251\002N\002O\001c\002\243\003\011\004(\001}\004\006\002\243\000\234\002\136\000\234\002\249\002\146\001\134\002n\001\135\001j\004\024\003\n\004\n\003\004\002R\002o\002\138\000\231\002\243\004\242\003\007\006\r\004\031\002\243\000\234\006\136\002\142\002\145\002\134\002!\004/\001\015\001#\004P\002\139\0049\002\149\001\021\001\"\002N\002O\001c\002\155\000\234\001\135\002\141\002\136\000\227\002\146\004\244\000\231\000\232\000\234\004R\002n\000\234\003\019\003\024\002R\001,\002\138\000\231\002o\000\234\004\245\002\157\002\243\004X\006\007\004\252\002\142\002\145\004e\004\253\000\234\002\134\000\234\002\139\004h\002\149\004\242\004r\002N\002O\001c\002\155\000\234\001\135\002\141\002\136\004m\002\243\002\146\001#\000\234\004x\002\243\002n\003\030\000\234\003%\002R\003$\002\138\000\231\002o\001\029\003)\002\157\004G\004\244\005\252\004\131\002\142\002\145\002\243\004\137\000\234\002\134\004\141\001,\002\139\003\\\005i\004\169\004\245\002N\002O\001c\002\155\004\252\001\135\002\141\001 \005\007\002\146\002\136\004\215\004\150\003b\003o\002n\000\234\005\022\003s\000\234\004\220\003u\002R\002o\002\138\000\231\002\157\003\130\003\139\005\237\005\b\003\144\002\243\003\156\002\142\002\145\002\134\004\191\002\139\003\154\002\149\003\157\004\217\002N\002O\001c\002\155\003\161\001\135\002\141\000\234\004\225\002\243\002\136\000\234\002\243\002\146\000\234\002n\005\004\001\225\004\228\000\234\002]\003\171\002R\002o\002\138\000\231\002\157\001\249\003\167\005\226\002\021\001\253\000\234\001\021\002\142\002\145\002\134\003\183\000\234\001\015\004\231\000\234\002\139\004\239\002\149\001\021\001\"\002N\002O\001c\002\155\000\234\001\135\002\141\002\136\000\227\002\146\006T\000\231\000\232\002 \005\011\002n\000\231\003\177\003\179\002R\003\202\002\138\000\231\002o\003\190\000\234\002\157\001\254\002\243\005\218\005\027\002\142\002\145\000\234\005\021\002\243\002\134\005\025\002\139\005/\002\149\004\242\001\255\002N\002O\001c\002\155\002\243\001\135\002\141\002\136\005;\002\243\002\146\001#\003\201\002\243\000\234\002n\003\196\000\234\003\200\002R\003\213\002\138\000\231\002o\002\243\003\218\002\157\002\243\004\244\005\177\006 \002\142\002\145\002!\006&\0048\002\134\006-\001,\002\139\003\223\002\149\0060\004\245\002N\002O\001c\002\155\004\252\001\135\002\141\000\234\005\023\002\146\002\136\002\243\002\243\005\029\002\243\002n\000\234\006S\006q\003\226\005!\003\230\002R\002o\002\138\000\231\002\157\003\238\000\234\003\245\006{\004\000\005-\005\169\002\142\002\145\002\134\0054\002\139\0047\002\149\005>\002\243\002N\002O\001c\002\155\0040\001\135\002\141\000\234\006}\005J\002\136\000\234\005Q\002\146\000\234\002n\006\162\001\225\006\174\000\234\002\241\0041\002R\002o\002\138\000\231\002\157\001\249\0046\002\132\002\021\001\253\002\243\001\021\002\142\002\145\002\134\004:\000\234\000\234\006K\006u\002\139\006\188\002\149\004;\004Z\002N\002O\001c\002\155\000\234\001\135\002\141\002\136\000\227\002\146\006r\000\231\000\232\002 \004S\002n\000\231\004T\004Y\002R\004o\002\138\000\231\002o\0071\000\234\002\157\001\254\002\243\002\144\004k\002\142\002\145\000\234\004l\000\234\002\134\004n\002\139\004z\002\149\004\242\001\255\002N\002O\001c\002\155\004w\001\135\002\141\002\136\004y\004\130\002\146\004\132\004\133\004\138\007<\002n\004\142\004\146\004\164\002R\004\170\002\138\000\231\002o\001\225\004\174\002\157\002\253\004\244\002\148\004\205\002\142\002\145\002!\001\249\004\226\002\134\004\255\001\253\002\139\001\021\005i\005\t\004\245\002N\002O\001c\002\155\004\252\001\135\002\141\0056\005)\002\146\002\136\0050\0051\007A\0055\002n\005<\001\225\005L\005\199\003\181\005\208\002R\002o\002\138\000\231\002\157\001\249\005\221\002\163\005\232\001\253\005\240\001\021\002\142\002\145\002\134\001\254\002\139\006\024\002\149\006%\006'\002N\002O\001c\002\155\006,\001\135\002\141\006/\006<\001\255\002\136\006R\006[\002\146\006\157\002n\006\179\007#\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\001\225\000\000\002\162\003\192\001\254\000\000\000\000\002\142\002\145\002\134\001\249\000\000\000\000\000\000\001\253\002\139\001\021\002\149\000\000\001\255\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\001\225\002n\000\000\003\198\000\000\002R\000\000\002\138\000\231\002o\001\249\000\000\002\157\000\000\001\253\002\210\001\021\002\142\002\145\000\000\000\000\000\000\002\134\001\254\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\001\255\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\001\225\000\000\002\157\003\207\001\254\002\213\000\000\002\142\002\145\000\000\001\249\000\000\002\134\000\000\001\253\002\139\001\021\002\149\000\000\001\255\002N\002O\001c\002\155\001\225\001\135\002\141\003\215\000\000\002\146\002\136\000\000\000\000\000\000\001\249\002n\000\000\000\000\001\253\000\000\001\021\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\002\234\000\000\000\000\000\000\000\000\002\142\002\145\002\134\001\254\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\001\255\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\001\254\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\001\225\000\000\004\145\006W\000\000\000\000\001\255\002\142\002\145\002\134\001\249\000\000\000\000\000\000\001\253\002\139\001\021\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\001\225\002n\000\000\006f\000\000\002R\000\000\002\138\000\231\002o\001\249\000\000\002\157\000\000\001\253\004\148\001\021\002\142\002\145\000\000\000\000\000\000\002\134\001\254\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\001\255\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\001\225\000\000\002\157\006i\001\254\004\163\000\000\002\142\002\145\000\000\001\249\000\000\002\134\000\000\001\253\002\139\001\021\002\149\000\000\001\255\002N\002O\001c\002\155\001\225\001\135\002\141\006l\000\000\002\146\002\136\000\000\000\000\000\000\001\249\002n\000\000\000\000\001\253\000\000\001\021\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\004\166\000\000\000\000\000\000\000\000\002\142\002\145\002\134\001\254\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\001\255\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\001\254\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\004\178\000\000\000\000\000\000\001\255\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\004\181\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\004\187\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\004\209\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\004\212\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\004\216\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\005_\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\005b\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\005g\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\005k\000\000\000\000\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\005m\000\000\000\000\002\134\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\005p\002\142\002\145\002\134\000\000\002\139\000\000\005i\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\005u\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\005i\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\005z\000\000\000\000\002\134\000\000\002\139\000\000\005i\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\005\127\000\000\000\000\002\134\000\000\000\000\002\139\000\000\005i\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\005\133\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\005i\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\005\138\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\005i\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\005\143\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\002\139\000\000\005i\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\005\150\000\000\000\000\002\134\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\005\155\002\142\002\145\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\005\160\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\005\172\000\000\000\000\002\134\000\000\002\139\000\000\005i\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\005\175\000\000\000\000\002\134\000\000\000\000\002\139\000\000\005i\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\005\180\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\005i\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\005\183\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\005i\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\005\192\000\000\000\000\002\134\000\000\002\139\000\000\005i\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\005\196\000\000\000\000\002\134\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\005\222\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\005\224\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\005i\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\005\228\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\002\139\000\000\005i\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\005\231\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\005\233\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\005\235\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\005\245\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\005\254\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\006\001\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\006#\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\006*\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\0062\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\006@\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\006E\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\006H\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\006\208\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\006\210\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\006\213\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\006\218\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\006\220\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\002\139\000\000\002\149\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\000\000\002\139\000\000\006c\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\006L\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\006\021\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\002\139\000\000\006\016\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\000\000\002\139\000\000\005\168\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\005]\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\002\151\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\002\139\000\000\002\153\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\000\000\002\139\000\000\002\158\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\002\165\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\002\167\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\002\139\000\000\002\169\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\000\000\002\139\000\000\002\171\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\002\173\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\002\175\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\002\139\000\000\002\177\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\000\000\002\139\000\000\002\179\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\002\181\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\002\183\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\002\139\000\000\002\185\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\000\000\002\139\000\000\002\187\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\002\189\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\001b\001c\000\000\002\136\000\000\000\000\002\146\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\001d\004\183\000\000\001f\001g\000\000\000\000\002\142\002\145\002\134\000\000\000\000\000\000\000\000\000\000\002\139\000\000\002\191\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\000\000\002\157\000\000\000\000\000\000\000\000\002\142\002\145\000\000\000\000\000\000\002\134\000\000\002\139\000\000\002\193\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\002\136\000\000\000\000\002\146\000\000\000\000\001k\000\000\002n\000\000\000\000\000\000\002R\000\000\002\138\000\231\002o\000\000\001l\002\157\000\000\000\231\000\000\004[\002\142\002\145\000\000\000\000\000\000\002\134\000\000\000\000\002\139\000\000\002\195\000\000\000\000\002N\002O\001c\002\155\000\000\001\135\002\141\000\000\000\000\002\146\002\136\000\000\000\000\000\000\004\\\002n\004]\000\000\005*\000\000\000\000\000\000\002R\002o\002\138\000\231\002\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\142\002\145\002\134\000\000\002\139\000\000\002\197\000\000\000\000\000\000\001}\004^\002\155\001\029\001\135\002\141\001\030\000\000\001\134\002\136\001\135\001j\002\146\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002R\005,\002\138\000\231\002\157\000\000\000\000\000\000\000\000\001 \000\000\001\029\002\142\002\145\001\030\004_\000\000\000\000\000\000\000\000\002\139\000\000\002\199\000\000\004`\004a\003q\004b\002\155\000\000\001\135\002\141\002\136\000\000\002\146\000\000\000\000\000\000\001 \000\000\000\000\000\000\000\000\000\000\002R\000\000\002\138\000\231\000\000\000\000\001\029\002\157\004}\001\030\001(\003q\002\142\002\145\001\029\000\000\000\000\001\030\000\000\002\139\000\000\002\201\000\000\000\000\003t\000\000\000\000\002\155\000\000\001\135\002\141\000\000\004d\001 \002\146\006\137\000\000\004f\004p\001(\001\015\001 \000\000\000\000\000\000\000\000\001\021\001\"\004{\000\000\002\157\000\000\000\000\003\153\000\000\000\000\000\000\000\000\003q\000\000\000\000\000\000\000\000\002\139\004|\002\203\000\000\000\000\000\000\001\015\000\000\002\155\000\000\001\135\002\141\001\021\001\"\000\000\001(\000\000\000\000\000\000\002N\002O\001c\000\000\001(\000\000\000\000\000\000\003w\003x\000\000\000\000\002\157\001<\000\000\002n\000\000\000\000\004v\000\000\001#\000\000\000\000\002o\003y\003\137\001\015\000\000\000\000\003\129\003_\000\000\001\021\001\"\001\015\000\000\002\134\003w\003x\000\000\001\021\001\"\001<\000\000\000\000\000\000\000\000\001,\000\000\001#\001F\000\000\000\000\003y\003\137\002N\002O\001c\003\129\003_\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\001,\000\000\002o\001F\000\000\001<\000\000\000\000\003w\003x\000\000\001\029\001#\001<\001\030\002\134\006\144\002N\002O\001c\001#\002\136\000\000\000\000\003y\003\137\000\000\000\000\000\000\003\129\003_\000\000\002n\002R\000\000\002\138\000\231\000\000\001 \001,\002o\000\000\001F\000\000\000\000\002\142\002\145\001,\0037\000\000\001F\000\000\000\000\002\134\000\000\000\000\000\000\000\000\002N\002O\001c\000\000\006z\000\000\000\000\000\000\000\000\002\146\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\002\136\000\000\000\000\000\000\000\000\002o\000\000\001(\000\000\000\000\000\000\000\000\002R\000\000\002\138\000\231\000\000\000\000\002\134\000\000\002\139\000\000\005x\000\000\002\142\002\145\000\000\000\000\002\155\000\000\001\135\002\141\000\000\000\000\000\000\000\000\000\000\001\015\002\136\000\000\000\000\000\000\000\000\001\021\001\"\000\000\002\146\000\000\000\000\000\000\002R\002\157\002\138\000\231\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\142\002\145\000\000\000\000\002N\002O\001c\000\000\000\000\000\000\000\000\000\000\000\000\002\139\000\000\005}\000\000\002\136\000\000\002n\000\000\002\155\002\146\001\135\002\141\000\000\000\000\002o\000\000\002R\001<\002\138\000\231\000\000\002N\002O\001c\001#\000\000\000\000\002\134\002\142\002\145\000\000\002\157\000\000\000\000\000\000\000\000\002n\000\000\002\139\000\000\005\130\000\000\000\000\000\000\002o\004[\002\155\000\000\001\135\002\141\002\146\001,\000\000\000\000\003>\000\000\000\000\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\157\002N\002O\001c\004\\\006\189\004]\000\000\000\000\000\000\002\139\000\000\005\136\000\000\000\000\000\000\002n\000\000\002\155\002\136\001\135\002\141\000\000\000\000\002o\000\000\000\000\000\000\000\000\000\000\000\000\002R\000\000\002\138\000\231\004^\000\000\002\134\000\000\000\000\000\000\002\157\000\000\002\142\002\145\002N\002O\001c\000\000\002\136\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002n\002R\000\000\002\138\000\231\002\146\000\000\000\000\002o\000\000\004_\000\000\000\000\002\142\002\145\000\000\000\000\000\000\000\000\004`\004a\002\134\004b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\139\002\146\005\141\000\000\002\136\000\000\000\000\000\000\002\155\000\000\001\135\002\141\000\000\004\127\000\000\000\000\002R\000\000\002\138\000\231\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\142\002\145\002\139\002\157\005\146\000\000\000\000\000\000\000\000\004d\002\155\000\000\001\135\002\141\004f\004p\002N\002O\001c\000\000\002\136\001\029\002\146\000\000\001\030\004{\000\000\000\000\000\000\000\000\000\000\002n\002R\002\157\002\138\000\231\000\000\000\000\000\000\002o\004[\004|\000\000\000\000\002\142\002\145\000\000\000\000\001 \000\000\000\000\002\139\002\134\005\153\002N\002O\001c\000\000\006A\002\155\000\000\001\135\002\141\000\000\000\000\000\000\002\146\000\000\004\\\002n\004]\002N\002O\001c\000\000\000\000\000\000\002o\000\000\000\000\000\000\000\000\002\157\000\000\000\000\000\000\002n\000\000\000\000\000\000\002\134\000\000\000\000\001(\002o\002\139\000\000\005\158\000\000\004^\000\000\000\000\000\000\002\155\000\000\001\135\002\141\002\134\000\000\002N\002O\001c\000\000\002\136\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\015\002n\002R\002\157\002\138\000\231\001\021\001\"\000\000\002o\000\000\004_\000\000\000\000\002\142\002\145\000\000\000\000\000\000\000\000\004`\004a\002\134\004b\000\000\000\000\000\000\000\000\002\136\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\146\000\000\000\000\000\000\002R\000\000\002\138\000\231\000\000\002\136\000\000\000\000\004c\000\000\000\000\000\000\002\142\002\145\000\000\001<\000\000\002R\000\000\002\138\000\231\000\000\001#\000\000\000\000\002\139\002v\005\163\000\000\002\142\002\145\000\000\004d\002\155\002\146\001\135\002\141\004f\004p\000\000\000\000\000\000\000\000\002\136\000\000\000\000\000\000\000\000\004{\001,\000\000\002\146\001F\000\000\000\000\002R\002\157\002\138\000\231\000\000\000\000\000\000\000\000\002\139\004|\005\166\000\000\002\142\002\145\000\000\000\000\002\155\000\000\001\135\002\141\001\174\001c\000\000\000\000\000\000\002\139\000\000\006\t\000\000\001\188\001c\000\000\000\000\002\155\002\146\001\135\002\141\000\000\000\000\002\157\002\206\001s\000\000\001f\001g\000\000\001\174\001c\000\000\001d\002b\000\000\001f\001g\000\000\000\000\002\157\000\000\000\000\000\000\000\000\000\000\000\000\002\139\000\000\006\011\002\206\001s\000\000\001f\001g\002\155\000\000\001\135\002\141\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\211\002\223\002\224\000\000\000\000\000\000\000\000\000\000\000\000\005\178\002\223\002\224\002\157\000\000\000\000\000\000\001\174\001c\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\211\002\223\002\224\000\000\000\000\000\000\000\000\000\000\001{\000\000\002\206\001s\000\000\001f\001g\001\174\001c\001{\000\000\000\000\001l\000\000\000\000\000\231\000\000\000\000\000\000\000\000\000\000\001l\000\000\000\000\000\231\000\000\001{\002\206\001s\000\000\001f\001g\000\000\000\000\000\000\000\000\001\174\001c\001l\000\000\000\000\000\231\000\000\000\000\002\211\002\223\002\224\002\227\006J\000\000\000\000\005\181\005\186\000\000\000\000\000\000\002\206\001s\000\000\001f\001g\0057\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\211\002\223\002\224\000\000\002\227\002\228\001}\0077\000\000\001{\0078\000\000\000\000\005?\001~\001}\001\135\001j\000\000\000\000\000\000\001l\005@\001~\000\231\001\135\001j\000\000\000\000\002\211\002\223\002\224\001}\000\000\001{\000\000\000\000\000\000\000\000\000\000\001~\000\000\001\135\001j\000\000\000\000\001l\000\000\000\000\000\231\000\000\005A\000\000\000\000\000\000\000\000\002\227\004\227\000\000\000\000\000\000\000\000\000\000\001{\000\000\001b\001c\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001l\000\000\000\000\000\231\001b\001c\002\227\005\n\000\000\001}\001d\001s\005B\001f\001g\000\000\000\000\001~\000\000\001\135\001j\005C\000\000\000\000\001d\001s\000\000\001f\001g\000\000\000\000\000\000\000\000\006\203\001}\002\227\005=\000\000\000\000\000\000\005D\002\145\001~\007:\001\135\001j\000\000\006\206\000\000\000\000\000\000\000\000\000\000\001t\000\000\001u\0029\000\000\000\000\001b\001c\000\000\005G\001}\000\000\000\000\000\000\001t\000\000\001u\0029\001~\005I\001\135\001j\000\000\000\000\005K\000\000\001d\001s\000\000\001f\001g\000\000\000\000\001{\000\000\005M\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001l\000\000\001{\000\231\000\000\000\000\005N\000\000\000\000\000\000\000\000\006\006\000\000\000\000\001l\001b\001c\000\231\000\000\000\000\000\000\000\000\000\000\000\000\001t\006\006\001u\001\139\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001d\001s\000\000\001f\001g\000\000\000\000\000\000\000\000\000\000\001\172\000\000\000\000\000\000\000\000\000\000\000\146\000\000\000\000\000\000\000\000\000\000\001{\000\000\000\000\000\000\000\000\000\000\001}\000\000\000\000\000\000\000\000\000\000\001l\000\000\001~\000\231\001\135\001j\000\000\000\000\001}\001t\000\000\001u\001\160\001b\001c\000\000\001~\000\000\001\135\001j\000\000\000\000\000\000\000\000\000\000\000\000\001b\001c\000\000\000\000\000\000\000\000\000\000\001d\001s\000\000\001f\001g\000\000\000\000\000\000\000\000\001{\001\158\001b\001c\001d\001s\000\000\001f\001g\000\000\000\000\004\185\001l\000\000\001\162\000\231\000\000\000\000\000\000\004\188\000\000\001}\001d\004\183\000\000\001f\001g\000\000\000\000\001~\000\000\001\135\001j\000\000\001t\000\000\001u\001\160\001b\001c\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001t\000\000\001u\001\160\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001d\001s\000\000\001f\001g\000\000\000\000\000\000\000\000\001{\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001}\000\000\000\000\000\000\001l\001{\000\000\000\231\001~\000\000\001\135\001j\000\000\001\029\000\000\000\000\001\030\001l\000\000\000\000\000\231\000\000\000\000\001k\001b\001c\001t\000\000\001u\0029\000\000\000\000\000\000\004\185\000\000\001l\000\000\000\000\000\231\000\000\001 \004\188\000\000\000\000\001d\004\183\000\000\001f\001g\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\001\188\001c\000\000\000\000\001}\000\000\000\000\000\000\001l\004\184\000\000\000\231\001~\000\000\001\135\001j\000\000\001}\000\000\006\002\001d\002b\001(\001f\001g\001~\000\000\001\135\001j\000\000\0064\000\000\000\000\000\000\000\000\001}\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\134\000\000\001\135\001j\000\000\000\000\000\000\000\000\000\000\001\015\001b\001c\000\000\000\000\001k\001\021\001\"\000\000\000\000\005\178\002\223\002\224\000\000\000\000\000\000\000\000\001l\000\000\001}\000\231\001d\001s\000\000\001f\001g\000\000\001~\000\000\001\135\001j\000\000\000\000\000\000\000\000\000\000\000\000\001b\001c\000\000\000\000\000\000\000\000\000\000\001{\000\000\000\000\000\000\000\000\000\000\001b\001c\000\000\000\000\004\184\001<\001l\001d\001s\000\231\001f\001g\001#\000\000\001t\000\000\001u\0029\000\000\000\000\001d\001s\000\000\001f\001g\004\189\000\000\000\000\000\000\000\000\001}\000\000\000\000\001\029\000\000\000\000\001\030\005\185\001\134\001,\001\135\001j\001\234\000\000\000\000\001\029\000\000\001{\001\030\000\000\001t\0010\001u\007\024\000\000\007\026\000\000\000\000\000\000\001l\001 \000\000\000\231\001t\000\000\001u\006\193\000\000\001:\001}\006\005\0011\001 \000\000\000\000\000\000\000\000\001~\001O\001\135\001j\000\000\000\000\001{\000\000\000\000\000\000\001\029\000\000\000\000\001\030\000\000\000\000\0010\000\000\001l\001{\000\000\000\231\000\000\000\000\000\000\000\000\000\000\000\000\001(\000\000\000\000\001l\000\000\000\000\000\231\001\029\0011\001 \001\030\000\000\001(\0010\000\000\001M\000\000\001}\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001~\000\000\001\135\001j\0016\001\015\000\000\000\000\0011\001 \000\000\001\021\001\"\000\000\000\000\0012\000\000\001\015\000\000\000\000\000\000\000\000\000\000\001\021\001\"\000\000\000\000\000\000\001}\001(\000\000\000\000\000\000\000\000\000\000\000\000\001~\000\000\001\135\001j\000\000\001}\000\000\000\000\000\000\000\000\0016\001\029\000\000\001~\001\030\001\135\001j\0010\001(\000\000\000\000\000\000\000\000\001\015\001<\000\000\000\000\000\000\000\000\001\021\001\"\001#\000\000\000\000\000\000\0016\001<\0011\001 \001b\001c\000\000\000\000\001#\001K\000\000\000\000\001D\001\015\000\000\000\000\000\000\004[\000\000\001\021\001\"\000\000\000\000\001,\001d\001s\001B\001f\001g\000\000\000\000\000\000\000\000\000\000\000\000\001,\000\000\000\000\001F\000\000\000\000\000\000\000\000\001<\000\000\004\\\006\226\004]\001(\000\000\001#\000\000\000\000\000\000\001D\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0016\000\000\001t\001<\001u\001\164\000\000\000\000\001b\001c\001#\004^\001,\001\015\001D\001F\000\000\000\000\000\000\001\021\001\"\001b\001c\000\000\000\000\000\000\000\000\000\000\001d\001s\000\000\001f\001g\000\000\000\000\001{\000\000\001,\000\000\000\000\001F\001d\001s\000\000\001f\001g\004_\001l\000\000\000\000\000\231\000\000\000\000\000\000\000\000\004`\004a\000\000\004b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001<\000\000\000\000\001t\000\000\001u\001\154\001#\000\000\001b\001c\001D\000\000\000\000\000\000\004\127\001t\000\000\001u\001\151\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001d\001s\000\000\001f\001g\001,\000\000\001{\001F\000\000\004d\006\228\000\000\001}\000\000\004f\004p\000\000\000\000\001l\001{\001~\000\231\001\135\001j\000\000\004{\000\000\000\000\000\000\000\000\000\000\001l\001b\001c\000\231\000\000\000\000\000\000\000\000\000\000\000\000\004|\001t\000\000\001u\001w\001b\001c\000\000\000\000\000\000\000\000\001d\001s\000\000\001f\001g\000\000\000\000\001b\001c\000\000\000\000\000\000\000\000\000\000\001d\001s\000\000\001f\001g\000\000\000\000\000\000\000\000\001{\000\000\000\000\000\000\001d\001s\001}\001f\001g\000\000\000\000\000\000\001l\000\000\001~\000\231\001\135\001j\000\000\001}\001t\000\000\001u\001y\000\000\000\000\000\000\001~\000\000\001\135\001j\000\000\000\000\000\000\001t\000\000\001u\001|\001b\001c\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001t\000\000\001u\001\150\000\000\000\000\001{\000\000\000\000\000\000\000\000\001d\001s\001\029\001f\001g\004D\000\000\001l\000\000\001{\000\231\000\000\000\000\001\029\000\000\000\000\001\030\001}\000\000\000\000\000\000\001l\001{\000\000\000\231\001~\000\000\001\135\001j\001 \001b\001c\000\000\000\000\001l\001b\001c\000\231\000\000\006F\001 \000\000\000\000\001t\000\000\001u\001\142\006I\000\000\000\000\001d\004\183\000\000\001f\001g\001d\001s\000\000\001f\001g\002N\002O\001c\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001}\000\000\000\000\000\000\004F\000\000\001{\000\000\001~\000\000\001\135\001j\000\000\005\202\001}\001(\000\000\000\000\001l\000\000\005\211\000\231\001~\000\000\001\135\001j\000\000\001}\001t\000\000\001u\001\147\000\000\000\000\001\015\001~\000\000\001\135\001j\000\000\001\021\004I\000\000\006\019\000\000\001\015\000\000\000\000\000\000\000\000\000\000\001\021\001\"\000\000\000\000\000\000\001k\000\000\000\000\000\000\000\000\001{\000\000\000\000\000\000\000\000\000\000\000\000\001l\000\000\000\000\000\231\000\000\001l\000\000\000\000\000\231\000\000\000\000\000\000\000\000\001}\000\000\000\000\000\000\000\000\000\000\002Q\000\000\001~\000\000\001\135\001j\001b\001c\000\000\004J\000\000\000\000\005\214\001<\002\138\000\231\001\002\000\000\004\184\000\000\001#\004\021\000\000\004O\001V\004L\001d\001s\000\000\001f\001g\000\000\000\000\000\000\000\000\000\000\001,\000\000\000\000\000\000\000\000\001b\001c\000\000\001}\000\000\000\000\001,\000\000\001}\001F\005\205\001\134\000\000\001\135\001j\000\000\001~\000\000\001\135\001j\001d\001s\000\000\001f\001g\000\000\001b\001c\001t\000\000\001u\002F\001b\001c\002\139\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\140\000\000\001\135\002\141\001d\001s\000\000\001f\001g\000\000\001d\001s\000\000\001f\001g\000\000\001b\001c\000\000\001{\000\000\001t\000\000\001u\002K\000\000\000\000\000\000\000\000\000\000\000\000\001l\000\000\000\000\000\231\000\000\001d\001s\000\000\001f\001g\000\000\000\000\000\000\000\000\000\000\000\000\001t\000\000\001u\002\215\001b\001c\001t\001{\001u\002\217\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001l\000\000\000\000\000\231\000\000\001d\001s\000\000\001f\001g\000\000\000\000\000\000\001t\001{\001u\002\219\000\000\000\000\000\000\001{\000\000\000\000\000\000\000\000\000\000\001l\000\000\001}\000\231\000\000\000\000\001l\000\000\000\000\000\231\001~\000\000\001\135\001j\000\000\000\000\000\000\000\000\001b\001c\001{\000\000\001t\000\000\001u\002\226\000\000\000\000\000\000\000\000\000\000\000\000\001l\000\000\000\000\000\231\000\000\001}\001d\001s\000\000\001f\001g\000\000\000\000\001~\000\000\001\135\001j\000\000\000\000\000\000\000\000\000\000\000\000\001{\000\000\000\000\000\000\001\029\000\000\000\000\001\030\001}\000\000\001G\000\000\001l\000\000\001}\000\231\001~\000\000\001\135\001j\000\000\000\000\001~\000\000\001\135\001j\001t\000\000\001u\002\232\001I\001 \000\000\000\000\000\000\000\000\004\014\000\000\000\000\000\000\001}\000\000\002N\002O\001c\000\000\000\000\000\000\001~\000\000\001\135\001j\0057\000\000\000\000\000\000\000\000\000\000\000\000\001{\000\000\000\000\000\000\000\000\000\000\005\202\000\000\0077\000\000\000\000\0078\001l\005\211\005?\000\231\001}\001(\000\000\000\000\000\000\000\000\000\000\005@\001~\000\000\001\135\001j\0057\000\000\000\000\000\000\000\000\000\000\0016\000\000\005\212\000\000\001\029\000\000\000\000\001\030\000\000\0077\001G\000\000\0078\001\015\000\000\005?\000\000\000\000\005A\001\021\001\"\000\000\000\000\000\000\005@\000\000\000\000\000\000\000\000\0057\001I\001 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\029\000\000\001}\001\030\000\000\0077\0010\002Q\0078\000\000\001~\005?\001\135\001j\005A\005B\000\000\000\000\000\000\005\214\005@\002\138\000\231\001\002\005C\000\000\0015\001 \000\000\001<\000\000\000\000\000\000\000\000\000\000\000\000\001#\001(\000\000\000\000\004C\000\000\000\000\005D\002\145\000\000\0079\000\000\000\000\005A\005B\000\000\000\000\000\000\0016\000\000\000\000\000\000\005\205\005C\000\000\000\000\000\000\001,\000\000\005G\001F\001\015\000\000\000\000\000\000\000\000\001(\001\021\001\"\005I\000\000\000\000\005D\002\145\005K\007=\002\139\000\000\000\000\005B\000\000\000\000\000\000\0016\002\140\005M\001\135\002\141\005C\000\000\000\000\000\000\000\000\000\000\005G\000\000\001\015\000\000\001b\001c\000\000\005N\001\021\001\"\005I\000\000\000\000\005D\002\145\005K\007B\001b\001c\000\000\000\000\0065\001<\000\000\001d\004\183\005M\001f\001g\001#\000\000\001b\001c\001D\000\000\005G\000\000\001d\004\183\000\000\001f\001g\005N\000\000\000\000\005I\000\000\000\000\004\182\000\000\005K\001d\004\183\000\000\001f\001g\001,\001<\000\000\001F\000\000\005M\001b\001c\001#\000\000\000\000\000\000\001D\001b\001c\000\000\000\000\000\000\000\000\000\000\000\000\005N\000\000\004\213\000\000\000\000\001d\004\183\000\000\001f\001g\000\000\000\000\001d\004\183\001,\001f\001g\001F\000\000\000\000\001b\001c\000\000\001k\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001l\001k\000\000\000\231\000\000\001d\004\183\000\000\001f\001g\0057\000\000\000\000\001l\000\000\001k\000\231\000\000\0057\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001l\0058\000\000\000\231\005?\000\000\000\000\000\000\000\000\0058\004\184\000\000\005?\005@\000\000\000\000\000\000\000\000\000\000\001k\000\000\005@\000\000\005\246\000\000\000\000\001k\000\000\000\000\000\000\000\000\001l\000\000\000\000\000\231\000\000\001}\004\184\001l\000\000\000\000\000\231\005A\005\249\001\134\000\000\001\135\001j\000\000\001}\005A\000\000\000\000\000\000\001k\000\000\000\000\001\134\000\000\001\135\001j\001b\001c\001}\000\000\000\000\001l\000\000\004\184\000\231\000\000\001\134\000\000\001\135\001j\004\240\000\000\000\000\005B\000\000\000\000\001d\004\183\000\000\001f\001g\005B\005C\000\000\000\000\000\000\000\000\000\000\000\000\001}\005C\001b\001c\000\000\000\000\000\000\001}\001\134\004\240\001\135\001j\005D\002\145\000\000\001\134\000\000\001\135\001j\005F\005D\002\145\001d\004\183\000\000\001f\001g\005R\005\002\000\000\002N\002O\001c\000\000\005G\001}\000\000\000\000\000\000\000\000\000\000\000\000\005G\001\134\005I\001\135\001j\000\000\000\000\005K\000\000\000\000\005I\006P\000\000\000\000\005\001\005K\000\000\000\000\005M\000\000\000\000\001k\000\000\000\000\001b\001c\005M\000\000\000\000\001b\001c\000\000\000\000\001l\005N\000\000\000\231\000\000\000\000\000\000\000\000\000\000\005N\000\000\001d\004\183\000\000\001f\001g\001d\004\183\000\000\001f\001g\001b\001c\001k\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001l\000\000\005*\000\231\000\000\000\000\001d\004\183\000\000\001f\001g\000\000\000\000\000\000\000\000\000\000\000\000\002Q\000\000\000\000\000\000\000\000\000\000\000\000\0057\000\000\000\000\000\000\001}\002R\000\000\002\138\000\231\000\000\000\000\000\000\001\134\005*\001\135\001j\000\000\000\000\0058\000\000\000\000\005?\000\000\000\000\000\000\000\000\005+\000\000\001k\000\000\005@\000\000\000\000\001k\0057\000\000\000\000\000\000\001\029\001}\001l\001\030\000\000\000\231\000\000\001l\000\000\001\134\000\231\001\135\001j\000\000\007.\000\000\000\000\005?\000\000\000\000\001k\005A\000\000\0053\000\000\000\000\005@\001 \000\000\000\000\002\139\000\000\001l\000\000\000\000\000\231\000\000\003\028\002\140\005\246\001\135\002\141\000\000\000\000\005\246\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\187\000\000\000\000\005A\000\000\005B\000\000\005\248\000\000\000\000\000\000\000\000\005\247\001}\005C\000\000\000\000\005\246\001}\000\000\001(\001\134\000\000\001\135\001j\000\000\001\134\000\000\001\135\001j\000\000\000\000\000\000\005D\002\145\001\029\000\000\005\251\001\030\005B\006v\000\000\000\000\001}\000\000\000\000\000\000\000\000\005C\000\000\001\015\001\134\000\000\001\135\001j\005G\001\021\001\"\000\000\001b\001c\000\000\001 \000\000\000\000\005I\000\000\005D\002\145\000\000\005K\007/\003\028\000\000\000\000\000\000\000\000\000\000\000\000\001d\004\183\005M\001f\001g\000\000\000\000\000\000\003!\000\000\005G\000\000\000\000\000\000\001\029\000\000\000\000\001\030\005N\000\000\005I\000\000\000\000\000\000\000\000\005K\001<\000\000\001(\000\000\000\000\000\000\001\029\001#\000\000\001\030\005M\003'\000\000\000\000\000\000\001 \000\000\000\000\000\000\000\000\001\029\000\000\000\000\001\030\000\000\003\028\005N\000\000\000\000\000\000\000\000\000\000\001\015\001 \001,\000\000\000\000\001F\001\021\001\"\004\003\000\000\000\000\003\028\000\000\000\000\000\000\001 \000\000\000\000\001k\000\000\000\000\001b\001c\000\000\000\000\003\028\004\179\000\000\001(\000\000\001l\000\000\000\000\000\231\000\000\000\000\000\000\000\000\000\000\000\000\004\200\001d\001\133\000\000\001f\001g\001(\000\000\000\000\000\000\000\000\002N\002O\001c\000\000\001<\000\000\000\000\001\015\000\000\001(\000\000\001#\000\000\001\021\001\"\003'\005\250\000\000\000\000\000\000\000\000\000\000\000\000\004\248\000\000\001\015\000\000\000\000\000\000\000\000\001\029\001\021\001\"\001\030\000\000\000\000\000\000\000\000\001,\001\015\000\000\001F\001}\000\000\000\000\001\021\001\"\004\249\000\000\000\000\001\134\000\000\001\135\001j\000\000\000\000\000\000\001 \000\000\000\000\000\000\001\029\001<\000\000\001\030\000\000\001k\003\028\000\000\001#\000\000\000\000\000\000\003'\000\000\000\000\000\000\000\000\001l\000\000\001<\000\231\004\210\000\000\000\000\000\000\000\000\001#\001 \000\000\000\000\003'\000\000\004\014\001<\000\000\001,\002Q\000\000\001F\000\000\001#\001(\001b\001c\003'\000\000\001\029\000\000\002R\001\030\002\138\000\231\000\000\001,\000\000\000\000\001F\000\000\000\000\000\000\000\000\000\000\001d\001\205\000\000\001f\001g\001,\000\000\000\000\001F\001\015\001(\001 \000\000\000\000\000\000\001\021\001\"\001\029\001}\000\000\001\030\0037\000\000\000\000\004\251\000\000\001\134\000\000\001\135\001j\000\000\000\000\000\000\000\000\000\000\003:\001\029\000\000\000\000\001\030\001\015\000\000\000\000\000\000\001 \001\029\001\021\001\"\001\030\002\139\000\000\000\000\000\000\000\000\000\000\000\000\001(\002\140\000\000\001\135\002\141\000\000\000\000\001 \001<\000\000\000\000\000\000\004\235\000\000\000\000\001#\001 \000\000\000\000\003'\001k\000\000\001\029\000\000\000\000\001\030\000\000\000\000\000\000\000\000\001\015\000\000\001l\001(\000\000\000\231\001\021\001\"\000\000\001<\000\000\001\029\001,\000\000\001\030\001F\001#\000\000\000\000\001 \004\019\000\000\001(\000\000\002N\002O\001c\000\000\000\000\000\000\000\000\001(\000\000\001\015\000\000\000\000\000\000\000\000\001 \001\021\001\"\000\000\000\000\001,\000\000\000\000\001F\004\248\000\000\000\000\000\000\000\000\001\015\000\000\000\000\001<\000\000\000\000\001\021\001\"\006\252\001\015\001#\000\000\001(\001}\000\000\001\021\001\"\000\000\000\000\000\000\000\000\001\134\000\000\001\135\001j\000\000\000\000\001\029\000\000\000\000\001\030\001(\000\000\000\000\000\000\000\000\001<\001,\000\000\000\000\003>\000\000\001\015\001#\000\000\000\000\000\000\004 \001\021\001\"\004#\000\000\000\000\000\000\001 \001<\000\000\000\000\000\000\000\000\001\029\001\015\001#\001\030\001<\000\000\004\019\001\021\001\"\002Q\001,\001#\000\000\001F\000\000\004 \000\000\000\000\005\028\001\029\000\000\002R\001\030\002\138\000\231\000\000\000\000\001 \001\029\001,\000\000\001\030\001F\000\000\000\000\000\000\000\000\001<\001,\001(\000\000\001F\000\000\000\000\001#\000\000\001 \000\000\006\253\000\000\000\000\000\000\000\000\000\000\000\000\001 \001<\000\000\000\000\004\250\000\000\000\000\000\000\001#\000\000\000\000\000\000\001\144\000\000\001\015\000\000\001,\001(\000\000\001F\001\021\001\"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\139\000\000\000\000\000\000\000\000\000\000\001,\001(\002\140\001F\001\135\002\141\002N\002O\001c\000\000\001(\000\000\001\015\002N\002O\001c\000\000\000\000\001\021\001\"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\018\000\000\001\015\000\000\000\000\001<\000\000\006\015\001\021\001\"\000\000\001\015\001#\002N\002O\001c\001\179\001\021\001\"\000\000\002N\002O\001c\000\000\000\000\000\000\001\029\000\000\000\000\001\030\000\000\000\000\000\000\002N\002O\001c\002P\000\000\001<\001,\000\000\000\000\001F\002i\001\029\001#\000\000\001\030\000\000\001\194\000\000\000\000\000\000\001 \000\000\000\000\002k\001<\000\000\000\000\000\000\000\000\000\000\000\000\001#\000\000\001<\000\000\001\239\000\000\000\000\001 \001,\001#\002Q\001F\000\000\001\241\000\000\001\029\000\000\002Q\001\030\000\000\000\000\000\000\002R\000\000\002\138\000\231\000\000\001,\000\000\002R\001F\002\138\000\231\000\000\001(\000\000\001,\000\000\000\000\001F\000\000\000\000\001 \000\000\000\000\000\000\002Q\000\000\000\000\002N\002O\001c\001(\002Q\000\000\000\000\000\000\000\000\002R\000\000\002\138\000\231\000\000\000\000\001\015\002R\002Q\002\138\000\231\000\000\001\021\001\"\002\127\000\000\000\000\000\000\000\000\000\000\002R\000\000\002\138\000\231\001\015\001\029\000\000\002\139\001\030\001(\001\021\001\"\000\000\001\029\002\139\002\140\001\030\001\135\002\141\000\000\000\000\000\000\002\140\000\000\001\135\002\141\002N\002O\001c\000\000\000\000\000\000\001 \002N\002O\001c\000\000\000\000\000\000\001\015\001 \001<\000\000\002\139\000\000\001\021\001\"\000\000\001#\002\137\002\139\002\140\002d\001\135\002\141\000\000\002\156\000\000\002\140\001<\001\135\002\141\000\000\002\139\000\000\000\000\001#\000\000\002Q\000\000\002t\002\140\000\000\001\135\002\141\001,\001\029\001(\001F\001\030\002R\000\000\002\138\000\231\001\029\001(\000\000\001\030\000\000\000\000\000\000\000\000\001\029\001,\001<\001\030\001F\000\000\000\000\000\000\000\000\001#\000\000\001 \000\000\002x\000\000\001\015\000\000\000\000\000\000\001 \000\000\001\021\001\"\001\015\000\000\000\000\000\000\001 \000\000\001\021\001\"\002Q\000\000\000\000\000\000\000\000\001,\000\000\002Q\001F\000\000\000\000\000\000\002R\000\000\002\138\000\231\000\000\000\000\000\000\002R\002\139\002\138\000\231\000\000\000\000\001(\001\029\000\000\002\140\001\030\001\135\002\141\000\000\001(\000\000\000\000\000\000\000\000\000\000\001<\000\000\001(\000\000\000\000\000\000\000\000\001#\001<\000\000\000\000\002\208\000\000\000\000\001 \001#\001\015\000\000\000\000\003 \000\000\000\000\001\021\001\"\001\015\001\029\000\000\000\000\004D\000\000\001\021\001\"\001\015\000\000\001,\000\000\002\139\001F\001\021\001\"\000\000\000\000\001,\002\139\002\140\001F\001\135\002\141\000\000\000\000\000\000\002\140\001 \001\135\002\141\000\000\000\000\001\029\000\000\001(\004D\000\000\000\000\000\000\000\000\001\029\000\000\000\000\004D\000\000\000\000\001<\000\000\000\000\001\029\000\000\000\000\004D\001#\001<\000\000\000\000\003\236\000\000\001 \001\029\001#\001<\001\030\001\015\003\248\000\000\001 \000\000\001#\001\021\001\"\004F\004\018\000\000\000\000\001 \002N\002O\001c\001,\000\000\000\000\001F\000\000\000\000\000\000\001 \001,\000\000\000\000\001F\000\000\000\000\000\000\000\000\001,\000\000\001\029\001F\004\247\001\030\001\015\000\000\004F\000\000\000\000\000\000\001\021\004I\000\000\000\000\004F\000\000\000\000\000\000\000\000\000\000\000\000\001<\000\000\004F\000\000\000\000\000\000\001 \001#\000\000\000\000\000\000\004\"\000\000\001(\001\029\001\015\000\000\001\030\000\000\000\000\000\000\001\021\004I\001\015\000\000\000\000\000\000\000\000\000\000\001\021\004I\000\000\001\015\000\000\001,\000\000\000\000\001F\001\021\004I\000\000\001 \000\000\001\015\000\000\004J\000\000\000\000\000\000\001\021\001\"\001(\000\000\001\029\000\000\002Q\004D\004\021\000\000\004N\000\000\004L\000\000\000\000\000\000\000\000\000\000\002R\000\000\002\138\000\231\000\000\001,\000\000\000\000\000\000\000\000\004J\000\000\000\000\001 \001\015\000\000\000\000\000\000\004J\001(\001\021\001\"\004\021\000\000\004M\001\029\004L\004J\004D\000\000\004\021\001<\004K\000\000\004L\000\000\000\000\001,\001#\004\021\000\000\004W\004\159\004L\000\000\001,\000\000\000\000\000\000\001\015\001\029\000\000\001 \001\030\001,\001\021\001\"\000\000\004F\000\000\000\000\000\000\000\000\002\139\000\000\001,\000\000\000\000\001F\001<\000\000\002\140\001\029\001\135\002\141\001\030\001#\001 \000\000\000\000\004\176\000\000\001\029\000\000\000\000\001\030\000\000\000\000\001\015\000\000\000\000\000\000\000\000\000\000\001\021\004I\000\000\004F\000\000\001 \000\000\000\000\000\000\001,\001<\000\000\001F\000\000\000\000\001 \000\000\001#\000\000\001\029\000\000\004\207\001\030\000\000\000\000\000\000\000\000\000\000\001(\000\000\000\000\000\000\001\029\001\015\000\000\001\030\000\000\000\000\000\000\001\021\004I\000\000\000\000\000\000\001,\000\000\001 \001F\000\000\000\000\001(\001\029\000\000\000\000\001\030\000\000\004J\000\000\001\015\001 \001(\000\000\000\000\000\000\001\021\001\"\000\000\000\000\004\021\000\000\005\015\000\000\004L\000\000\000\000\000\000\001\029\000\000\001 \001\030\001\015\000\000\000\000\001,\000\000\000\000\001\021\001\"\000\000\000\000\001\015\001(\000\000\000\000\000\000\004J\001\021\001\"\000\000\000\000\000\000\000\000\000\000\001 \001(\000\000\000\000\004\021\000\000\005'\000\000\004L\000\000\001<\000\000\000\000\000\000\000\000\000\000\000\000\001#\001\015\001,\001(\006>\000\000\000\000\001\021\001\"\000\000\000\000\000\000\000\000\000\000\001\015\001<\000\000\000\000\000\000\000\000\001\021\001\"\001#\000\000\000\000\001<\006C\001,\001(\000\000\001F\000\000\001#\001\015\000\000\000\000\006\143\000\000\000\000\001\021\001\"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001,\000\000\000\000\001F\000\000\000\000\000\000\001<\000\000\001\015\001,\000\000\000\000\001F\001#\001\021\001\"\000\000\006\147\000\000\001<\000\000\000\000\000\000\000\000\000\000\000\000\001#\000\000\000\000\000\000\006\196\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001<\000\000\001,\000\000\000\000\001F\000\000\001#\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001,\000\000\000\000\001F\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\001#\000\000\001,\000\000\000\000\001\236\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\0039")) + ((16, "\002\168\001\133\000S\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\001#\001\234\000)\0019\000\179\000\017\000\135\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\155\000\000\000\000\000\000\000\000\000\000\000M\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \204\000\000\000\000\000\000\000\006\000\000\000\000\000\000\000\000\000\000\000\000\000\0008\214\000n\000\000\000N\000\029\000\193\000\000\000\196\000\017\000\218\001l\000Z\000\000\000\000\000\000\000b\000\000\000\000\000\016\000\000\000\000\000\000\000\000\002D\000\000\001d\000\000\000\000\000\000\000\000\000\000\000d\000\000\000,\002\234\000\015\000\000\000\000\011\1728\214\000\000\000\000\025\152\000\000\012x\000\0009p\003\134\003\152\000\000\000\000\001\166\001\236\001\182\004h\000v\002\234\002\216\000{\003\148\000\200\001\246\003\208\014\128\000\000\005(\002\n\004\216\002\bBV\000\000\000\000\000\000\000\000\000\000\000\000\000\0009\162\000\000\002<\005\024\003\020\000\000\000\000\000\000\000\000\002t\000\000\000\000\005\"\004~\000\000\005,\007<\t\028\000\000\000\000\000\000\002\186\003\"\005J\005\196\bX\005\1389\188\003*\005\194\001$\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\242\000\000\000\000\000\000\003\156\006\002\014\242\007\180\005(\"\144\000\000:\028\005\152:\164:\192\000\000\000\249\000\000\000\000\000\000\004\140Kx\004\210\000\000\012:\004\236\000\000\012\162\bb\000\254\000\000\004P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r0\004~\000\000\000\000\000\000\017@\000\000\nP\000\000\000\000\004~K\156\"*\000\000\017\228\000\000\000\000\000\000\000\000\000\000\000\000\002\134\011\210\002\134\004\006\000\000\000\000\000\000\004n\000\000\000\000\000\000\000\000\005\006\000\000\000\000\002\134\000\000\000\000\000\000\000\000\000\000\tR\000\000\006\210\005\162\000\000K\252\006\224X\252\000\000\000\000\000\000\000\000\004n\000\000\000\000\000\000\rH\000\000\000\000\000\000\000\000\000\000\000\000\000G\005\154\000\000\000\000\000\000\004n\005\224L\160\005.\007\014?\226\000\000\0050\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\230\000\000\000\000\000\000\000\000\006jL\236\000\000\005Z\007(M*\000\000\000\000\000\000M^\005\146Mx\005\146\000\000N\002\005\146\000\000NF9\162\006p\006\230\000\000\000\000Al\000\000\000\000\000\000\000\000\000\000\000\000\005\146\000\000N|\005\146N~\004n\000\000O\128\005\146\000\204\000\000\005\146\005\146\000\000\000\000\005\146\000\000:\192\000\000\000\000\000\000\005\146;H\000\000\000\000\005\146\000\000\000\167\007\014\000\000\000\000\000\000\000\000\000\000\000\000\020v\000\000\006\186\000\000N\228\004n\000\000\000\000\000\000\000\000\007\012\007\170\015<\007\006\b\002\b\016\0074\b\150\007H\000\154\b\186\000\000\000\000\003\006\003p\000\000\006\022\007V\001\002\bh\000\000\000\000\007\222\000\000\000\252\001*\005\196\000\221\t\212\000\000\000\000Y\022\000\000Y@\t\162\000\000O\012\004nO|\004n\000\000\002r\002\156\000\000\b\206\000\252\000\000\000\000\b\238\000\000\000\000\000\000\000\000\000\000\t\158\000\252\011.\000\252\000\000\004f\000\000\000\000\004\236\000\000\000\000\000\000\nj\000\000\000\000\000\252\000\252\000\000\000\252\000\000\000\000\tB\000\000\000W\bX\000\000\000W\000\000\r\242\000\252\000\000\000\000\000\000\000\000\000\000\000W\015\174\"\194\n\"\t\218:\246\023\022\000\0005l;\152\t&\007x5\160\t>\007\158\016\n\td\007\176\016\132\tp\007\238\004\174;\192\005\146\016\246\tz\007\254\023\132\n|\000\000<`\005\146O\220\004n\nX\000\000\000\000\000\000\000\0009\162\nB\000\000\000\000F\210\000\000\000\000\000\172\000\000\000\000\nz\026\254\002\134\000\000\017n\t\202\b\b\007b\000\000;\246\t\246\bB\025\194\000\000<\198\000\000\000\000\n\020\bRP*\005\146\017\150D\030\000\000\000\000\000\000\000\000\000\000\001\006\r\170\000\000\000\000\000\000\nF\br\n\012\000W\014,\000\252\000\000\000\000\000\000\005\152\000\000Pr\004n\018\014\nd\bvIr\000\000N\176\000\000\000\000\"\248\nn\b\142\030\178\000\000#b<\208\nv\b\156#\152\000\000.\136\000\000\000\000\011\224P\198\004nED\004nP\218\004n\000\000\000\000\000\000\000\000\000\000S\192\000\000\000\000\000\000\004\"\018\128\000\000\000\000\000\000=\132\n\146\b\160$$\000\000Z(\000\000\000\000\000\000\000\000\000\000\n^\018\250\000\000\000\000\nn=\206\n\176\b\182$`\000\000\nn=\226\n\182\b\230$\150\000\000\nn\000\000ZB\000\000>T\n\188\b\238% \000\000\nn\019V\004|\019\162\000\000\000\000>\138\n\210\t\"%^\000\000\nn>\188\n\228\t.%\196\000\000\nn?^\011\n\t<%\232\000\000\nn?\144\011\012\tB&&\000\000\nn?\194\011\020\tJ&\140\000\000\nn@8\011&\tZ&\238\000\000\nn@L\0114\tl'T\000\000\nn@\150\011<\t\186'\142\000\000\nnAJ\011X\t\192'\198\000\000\nnA\208\011v\t\248(P\000\000\nnB\026\011\128\n\002(\136\000\000\nnBB\011\136\n\006(\148\000\000\nnBx\011\152\n\014(\250\000\000\nnB\140\011\160\n\016)\\\000\000\nnC\128\011\174\n(*\002\000\000\nnC\246\011\218\nP*\030\000\000\nnD\n\011\222\nT*h\000\000\nnDT\011\236\nX+\b\000\000\nnDh\011\242\nd+*\000\000\nnD|\011\252\n\142+\202\000\000\nn\n\162\015\186\019j\020B\000\000ED\012\172\000\000Qj\004n\020\234\000\000\000\000\012B\000\000Q~\004n\0216\000\000\000\000\021\190\000\000\000\000\002j\000\000\000\000\022\"\000\000\000\000\000\000\000\000Q\194\004n\022\194\000\000\012\b\023\"\000\000Rn\005\146R|\005\146R\144\005\146\003$\000\000\000\000\000\000\000\000Sv\005\146\000\000\002\162\0054\000\000\000\000\000\000\nn\023\142\000\000\000\000\023\236\000\000\000\000\000\000\000\000+\164\000\000\000\000\nn,\000\000\000,r\000\000\000\000,\206\000\000\000\000\000\000Z\146\000\000\000\000-.\000\000\000\000Ev\012D\n\208-\152\000\000\nn-\138\000\000\000\000E\212\012L\n\228-\212\000\000\nn.\146\000\000\000\000F*\012z\n\236.\156\000\000\nn\004\138\024^\000\000\000\000FL\012\132\011\018/\018\000\000\nn\024\188\000\000\000\000Ft\012\136\011\026/\\\000\000\nn\025\026\000\000\000\000G\"\012\162\011.0\026\000\000\nn\000\000\000\0000b\000\000\000\000G\220\012\182\01180\144\000\000\nn0j\000\000\000\000H\014\012\228\011:0\220\000\000\nn18\000\000\000\000H\026\012\234\011H1\158\000\000\nn\000\000Hd\012\252\011T2\016\000\000\nn\000\000;\184\000\000\000\000\nn\000\000\000\000\000\0002F\000\000\000\0002\156\000\000\000\000\000\000\012\b\025v\000\000\000\000\026$\000\000H\132\000\000\000\000D\030\000\000\000\0002\230\000\000\000\000\000\0003J\000\000\000\000\000\000\014\"\000\000\000\000S8\000\000\000B\000\000\007\\\r\190\000\000\002f\000\000\000\000\000\000\000\000\000\000\001\006\000\000\000\000\r\020\000\000\000\000\026b\000\000\026\174\000\000\000\000\nn\000\000\000\000\027\016\000\000\027N\000\000\000\000\000\000\000\000\000\000H\200\r\026\011z3l\000\000I\162\r`\011\1363\176\000\000\nn\nnI\236\rj\011\1384R\000\000\nn\000\000\000\000\000\000\000\000\rl\011\1504\132\000\000\000\000\nn\000\000\000\000\000\000\000\000\rr\011\1544\200\000\000\nn\000\000\014\168\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\188\011\196\000W\028\026\000\000\r\152\011\190\014Z\001<\012\216\000W\015`\000\252\012\218\000W\000\000\028L\000\000\006<\000\000\r\230\011\230\002\216\000\000\000\000\000\000\000\000\000\000\014\n\003\178\000\235\000\000\000\000\000\000J\000\000\000Y\224\000\000\011\234\000\000\011\242\000\000\000\000\000\000\000\000\000\151\000\000\000\000\000\000)\188\002\134\000\000\002\134\0064\000\000\005\230\000\000*\178\002\134\002\134\000\000/\148\002\134\002\134\011\244\000\000\028\214\000\000\000\000\011\254\014\238\000\0005\020\006\252\000\000\000\000\000\000\000\000\000\000\000\000\r\254\012&5\134\000\000\nn\000\000\000\000\000\000\000\000\014\n\012P\rv\000W\000\000\0176\000\252\000\000\015f\000\000\000\000\000\000\000\0005\236\000\000\014\030\012\1406*\000\000\000\000\018\220\000\252\000\000\019\004\000\252\000\000\019\"\000\252\000\000\nn\000\000\020\198\000\252\000\000\021\140\000\252\000\000\022\\\000\252\000\000\000\026\000\000\012\170\r\142\001\168\000\000\014.\014F\012\182\014\192\015V\022\144\000\252\007\128\000\000\012\194\015~\015\134\007H\007\156\015P\012\196\015\150\007\142\007\168\015`\000\000\000\000\b(\b\134\000\000\004\186\004\136S\138\005\146\029\b\000\000\006\198\001\184\015\014\r\012\014x\004\236\000\000\015\016\r\016\004`\000\0006N\000\000S\212\004n\000\000\015\186\015\212\000\000\b\174\000\000\004n\015D\r \004\b\015\128\002\228\000\000\000\000\000\000\000\000\r(\b\186\000\000\rH\b\228\000\000\t\224\028J\015d\015f\r|\005\198\t@\000\000\r\160\007\228\t\242\000\000\015l\015p\r\172\015\208\015V\022\214\000\252\000\000\r\182\016:\000\000\b\138\n0\000\000\016>\000\000\025\244\001\206\016\012\r\214\016j\000\000\026\134\003\002\016:\000\000\000\000\000\195\003\134\n2\000\000\027\214\000\252\n\134\000\000\005\030\000\000\016\016\r\218\0298\004>\000\000\016\020\r\246\006F\015\128\016\022\016$\r\250\017\148\000\000\0168\002\140\000\000\000\000\000\000\000\000\000\182\014\016\016\nT\030\004n\000\000\004R\014\030\016\212\000\000\000\000\000\000\000\000\000\000\000\000T8\004\176\000\000\014,\017<\000\000\000\000\000\000\000\000\000\000\000\0006z\n\216\000\000\014:\001\b\000\000\014J\014h\006\"\000\000\001nI\188\000\000\005N\000\000U\006\004n\004n\000\000\000\000\005\180\000\000\t\006\000\000\001\132\005\180\005\180\000\000\014pJ>\004nUH\004n\011\000\000\000\000\000\000\000\012D\000\000\000\000\004\132\000\000\005\190\016\158\014~\017\190\016h\000\000\000\000\002\180\006h\016\176\000\000\000\000\014\136\017\204\016p\000\000\000\000\nd\000\000*\200\000\000U\028\002\222\004n\000\000UlL`\000\000V\004\000\000\000\000\000\000\005\180\000\000\000\000\012\192\016\184\014\150\017\212\016\136\000\000\000\000V.\012\250\016\208\000\000\000\000\000\000/\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r*\000\000\016\222\014\156\006\218\000\000\017\218\017\138\r\128\016\230\000\000\000\000\016\234\014\160\b\128\000\000\000\000\n(\bb\002\224\000\000\000\000\000\000\b\018\016\188\014\186\000\000\016\208\b\018\000\000\017\182\r\212\017\022\000\000\000\000\000\000\004n\002\182\006\196\006L\000\000\000\000\000\000\000\000\016\236\014\210\000\000\006\230\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004n\016\208\014\226\018>\016\226\000\000 \014\001\003\014\228\016\180\001r\002T\014\230\017t\000\000\0182\029\176\000\000\000\000\030\018\000\000\014x\000\000\004\242\000\000\000\000\000\000\000\000\000\000\000\000V\236\004n\000\000\0188\030\132\000\000\000\000\030\232\000\000\003b\014\246\017\222\000\000\000\000\021V7f\017\148\000\000W\004\004n\031N\000\000\000\000\031\156\000\000\000\000\014\158\000\000\002\206\000\000\000\000\000\000\000\000\000\000\000\0007x\000\000\000\0007 7\232\017\150\000\000W\022\004n V\000\000\000\000 \178\000\000\000\000\015\014!\004\014\176\000\000\015$\015@\000\145\001P\015L\b\202\015t\017\2428z\014\178\000\000\015\160\015\162\tr\000\000\003\182J\228\000\000\006\244\000\000\015\176\001\156\002\140\006\194\016\194\n\240\000\000Y\164;\184\000\000\b\150\000\000\000\000\b\150\000\000\000\000\b\150\nB\000\000\012\228\b\150\017\2468\142\014\186\000\000\b\150\000\000W0\000\000\000\000\b\150\000\000\000\000\014\190\000\000\r\020\t\220\015\n\000\000\015\180J\144\015\018\000\000\000\000\000\000\015 \000\000\000\000\001\234\000\000\b\150W@\000\000\016\030\b\150\"X\000\000\015$\017R\015\184\018r\017\028\000\000%\128\015T\017b\000\000\000\000\000\000\n$\007\006\000\000\000\000\000\000\000\000\000\000\000\000\n^\015\160\000\000\017t\000\000\000\000\000\000\000\000\015\210\016\232\000\000\000\000\000\000\n^\000\000\000\000\000\000\000\000\015\236\024\200\000\000\000\000\000\000\000\000\000W\000\252\000\000\005\146\000\000X\020\004n\000\000\003\202\000\000\000\000\000\0008\132\000\000\000\000\000\000\000\000\000\000\018\022\006\148\b\152\016\188\005\024\015\244\000\000\006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\236\006T\016\012\000\000\b\000\018x\018,\015\238\000\000\000\000\018 \n\254\007X\000\000\000\000\000\000\016\018\000\000\0164\015\248\000\000\000\000\002\134\020\004\000\000\000\000\000\000\000\000\000\000\027\252\000\000\000\000\b\230\007\224\000\000\000\000X.\004n\004nX\178\004n\007\182\000\000\000\000\000\000\004n\000\000\000\000\n\198\0180\0164\000\000\000\000\018$\003N\000\144\000\000\000\000\000\000\000\000\b\240\018x\011j\018<\016\182\000\000\000\000\0184\003x\006\242\000\000\000\000\000\000\000\252\000\000\016\206\000\000\000\000\000\000!,\000\000!\212\000\000\000\000\000\000\000\000\000\000\000B\000\000\000\000\000\000\003F\000\135\000\000\000\000\000\000\000\000\000\000\006\016\000\135\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003V\000\000\000\000\000\000K&\000\000\004n\000\000\014$\000\000\000\000\000\000\001\210\000\000\000\000\000\000\001H\000\000\000\000\000\000\005\014\000\000\000W\000\000\001&\000\000\000\252\000\000\005\238\000\000\000\000\000\000Bp\005\146\000\000\000\000\002T\000\000\000\000\000\000\000\000\001\006\005x\017p\000\164\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000=F\000\000\016\240\000\000\000\000\000\000\000\000\006L\b,\022\154\030\160\000\000\000\000\017\000Sd\000\000\000\000\000\000\017\006Z\026\000\000\000\000\000\000\000\000"), (16, "\006\219\0007\002`\002a\001j\000\231\000;\004\136\000\235\000\236\000\231\007l\005\235\000\235\000\255\000m\001j\002\133\006\220\006\235\003y\006\222\001\000\001\026\000\231\002\138\001\027\000\235\000\255\001\214\006\223\006\236\007f\001Y\000\145\005`\006\155\000\150\002\161\001\238\005\236\007d\005\237\001\242\000?\001\018\0007\001\002\000j\004\136\001\029\000\231\007Q\005\235\000\235\000\255\004\147\004\149\004\151\002\020\006\224\001\219\000\231\001\177\006\239\000\235\000\236\000@\006\015\000\151\006\157\000\145\005\238\007Y\001\231\000\145\000\145\000\155\001\231\000\154\000\238\005\236\007u\005\237\001\243\004\026\006\158\001\\\001\002\007\r\005b\006\160\007\012\006\155\003y\006\201\001#\006\225\004\150\004\149\004\151\000Y\002\167\001\244\007\187\002a\001j\006\226\005\239\001i\001j\001\031\007L\005\238\002d\002\020\002\169\000\235\005\240\005\241\006\219\005\242\002`\002a\001j\001\156\001j\006\157\001 \001k\002E\006\240\001m\001n\001\018\001&\000\238\002\133\006\220\006\235\000]\006\222\000\127\006\158\006.\002\138\006\241\001\210\006\160\005\239\006\223\006\236\006\181\003y\004&\001j\006\229\001\012\002\161\005\240\005\241\006\231\005\242\001\018\001&\001\255\004\234\000\231\005\244\002\176\000\235\000\255\002\177\005\246\006\000\006\233\006\022\006\023\000a\002\170\006\224\0012\002\021\000u\006\239\006.\000:\006*\002\191\001(\001\142\002\172\001)\006\234\001\012\001*\001+\006\024\006(\001\210\001\018\001&\006 \004\172\004\027\006+\007j\003y\001r\005\244\007w\000\238\002\193\002\000\005\246\006\000\007\188\006\225\002\169\000\235\001s\001,\002\167\000\235\0016\007U\001\012\006\226\006*\001i\001j\0009\001\018\001\021\002d\000|\002\169\000\235\002\021\000~\006\219\007\163\002`\002a\001j\000\145\006+\007!\001\231\001k\002E\006\240\001m\001n\000\130\002G\007V\002\133\006\220\006\235\007\155\006\222\001\012\002\t\002\003\002\138\006\241\001\012\001\018\001\021\006\223\006\236\001\214\001\018\001\021\007\164\006\229\002H\002\161\005F\000\231\006\231\001\238\000\235\000\236\001\132\001\242\0007\001\018\002\176\005\164\004w\002\177\003y\001\141\006\233\001\142\001q\007\156\002\170\006\224\000\235\000\231\005\165\006\239\000\235\000\236\005\188\002\191\000\132\001\142\002\172\003y\006\234\002\020\001\212\002\003\000\149\001\012\006D\007\175\002a\001j\000\238\001\018\001\021\007\n\001\243\001r\001\012\007\151\005\164\002\193\006\155\006\194\001\018\001\021\006\225\000\133\001\022\001s\003\\\002\167\000\235\005\165\004z\001\244\006\226\005\172\001i\001j\001\237\000\145\0011\002d\000\150\002\169\000\235\000\148\004\031\006\219\006\196\002`\002a\001j\004\238\000\237\006\157\007\152\001k\002E\006\240\001m\001n\001\018\006\153\006n\002\133\006\220\007q\006\198\006\222\005\164\006\158\005Q\002\138\006\241\005t\006\160\007\177\006\223\006\236\006\176\005\164\006\200\005\165\006\229\001\026\002\161\005\166\001\027\006\231\000\175\001N\000\179\001\132\005\165\000\238\006\199\002\176\005\171\000\174\002\177\003]\001\141\006\233\001\142\001q\003y\002\170\006\224\006\196\006\015\001P\001\029\003q\001j\006\166\002\191\005\158\001\142\002\172\007\178\006\234\002\169\000\235\000\180\002\021\006r\001\214\006\198\000\231\006\253\007|\000\235\000\255\006\242\001\249\001r\001\238\000\235\000\184\002\193\001\242\006F\001\018\001\237\006\225\001\012\001\234\001s\000\189\002\167\000\235\001\018\001&\003y\006\226\006\199\001\238\001#\000\238\000=\001\242\002d\001\018\002\169\000\235\004\027\007\004\006\219\001\012\002`\002a\001j\001\031\000\202\001\018\001\021\001C\003{\006\240\004\136\0007\001\243\006\153\007T\002\133\006\220\006\235\0007\006\222\001 \001\026\005*\002\138\006\241\000\235\001\018\001&\006\223\006\236\001\214\001\244\001\243\002\007\006\229\007b\002\161\007s\007}\006\231\001\238\000\238\000\206\001\132\001\242\007\139\001\018\002\176\006\022\006\023\002\177\004\152\001\141\006\233\001\142\001q\005W\002\170\006\224\006\b\004\149\004\151\007+\005\164\001p\006\165\002\191\004\235\001\142\002\172\006'\006\234\007~\0012\006 \004\172\005\165\007\133\001\018\005*\005\196\001(\000\235\001\214\001)\001\243\002\005\001*\001+\005\211\002\193\004\132\004\172\001\238\006g\006\225\005-\001\242\001\142\001\018\002\167\005\024\001j\005\\\001\244\006\226\000\235\006i\000\145\001\031\000\177\001\231\002d\001,\002\169\000\235\0016\007\134\006\219\000\222\002`\002a\001j\000\228\007W\007X\001 \000\231\001\237\006\240\000\235\000\236\001\018\001&\0007\002\133\006\220\006\235\001\243\006\222\001i\001j\003y\002\138\006\241\007W\007X\007\135\006\223\006\236\006 \004\172\007\005\007\140\006\229\001\142\002\161\001\244\006\155\006\231\001k\001z\000\185\001m\001n\0007\007\136\002\176\001\012\006K\002\177\006 \004\172\006\233\001\018\001\021\000\238\002\170\006\224\006\196\000\243\003\132\006\244\0048\000\235\000\255\002\191\001(\001\142\002\172\001)\006\234\006\157\001*\001+\002\011\000\170\004\155\006\198\003y\002`\002a\001j\000\182\001{\001\014\001|\002/\006\158\001^\002\193\001\018\001e\006\160\005h\006\225\001\251\006\167\003\146\004\156\002\167\005\181\001\018\004\192\006\252\006\226\006\199\002\022\001q\003y\000\235\000\238\002d\003\205\002\169\000\235\000\235\000\255\006\219\001\130\002`\002a\001j\005'\004\172\0010\005\187\005\183\001\006\006\240\002\020\001s\007\190\007\191\000\235\002\133\007\193\001\181\001j\006\222\007\159\001\t\002Y\002\138\006\241\003y\005\185\002\011\006\223\007\195\003\234\005\137\005\183\001\025\006\229\006O\002\161\001k\002t\006\231\001m\001n\000\145\001\254\001\218\001\231\001\237\002\176\005\186\001\018\002\177\005\185\002\023\006\233\000\190\001:\007\160\002\170\006\224\002\022\002c\005\020\000\235\001\026\005*\005c\002\191\000\235\001\142\002\172\0015\006\234\002d\005\186\002\169\000\235\001\132\001\012\007\131\002\201\004\000\003s\003t\001\018\001&\001\133\000\203\001\142\001q\003y\002\193\000\212\001\012\004\152\003y\006\225\000\215\003z\001\018\001\021\002\167\0019\001\026\0015\006\219\006\226\002`\002a\001j\007\210\005\t\000\223\002d\001F\002\169\000\235\001\130\001[\002\011\007\202\005b\002\133\007\203\000\238\002\023\006\222\007\198\003y\001s\002\138\007\167\000\235\004\152\002\021\006\223\007\211\001\172\002\170\007\019\004\158\001\142\001a\002\161\000\226\006\241\001\170\002\171\004\233\001\142\002\172\002\022\001\031\0059\000\235\006\229\000\238\004\003\004\b\001\018\006\231\000\238\005\173\007\168\001x\006\224\000\238\005\189\002\176\001 \005\160\002\177\000\229\001\238\006\233\001\018\001&\001\242\002\170\001\018\003y\000\238\000\145\001\214\005\249\001\231\002\004\002\191\0007\001\142\002\172\001\031\006\234\001\238\001\132\007\021\000\239\001\242\005\155\001\018\007\022\000\235\006\225\001\133\000\244\001\142\001q\002\167\001 \004\136\004{\002\193\006\226\000\238\001\018\001&\002\023\001\129\001\243\002d\006\015\002\169\000\235\005*\001\138\006\219\000\235\002`\002a\001j\001(\007\023\007\215\001)\005\167\007\132\001*\001+\001\243\005\167\004\160\000\238\002\133\006\220\006\250\007\024\006\222\001i\001j\003y\002\138\006\241\005\197\003\\\003y\006\223\006\236\001\244\006\028\004\149\004\151\006\229\004\163\002\161\004z\000\238\006\231\001k\001z\001(\001m\001n\001)\000\238\002\176\001*\001+\002\177\000\231\004\164\006\233\000\235\000\236\001\137\002\170\006\224\004\136\002`\002a\001j\002Q\005l\004\172\002\191\001\176\001\142\002\172\007\031\006\234\001\142\003y\004\167\002\133\000\231\007\025\007\026\000\235\000\236\001L\006\155\002\138\001{\001\187\001|\002/\001J\004\201\002\193\007\027\007\028\003y\007c\006\225\002\161\005\167\004\028\004\178\002\167\006\022\006\023\007\029\004\172\006\226\007&\003y\006$\004\149\004\151\001b\002d\003y\002\169\000\235\006\157\004\252\006\219\001\130\002`\002a\001j\006\031\001y\007V\001\192\006 \004\172\006\240\001\198\001s\006\158\007\202\000\235\002\133\007\203\006\160\004\180\006\222\001\200\006\164\002Y\002\138\006\241\007*\005\015\001\209\006\223\007\206\000\238\004\173\005\001\000j\006\229\001\026\002\161\000\238\001\027\006\231\002\167\001N\006\150\004\136\002$\004\247\000\145\002\176\006\003\001\231\002\177\004z\002d\006\233\002\169\000\235\007\023\002\170\006\224\004\253\000\238\001P\001\029\002'\001\214\005\002\002\191\001\215\001\142\002\172\007\024\006\234\002*\000\238\001\238\001\012\001\132\005=\001\242\000\238\001\018\001\018\001\021\001\018\002\173\001\133\004z\001\142\001q\000\238\002\193\001\012\007G\004\149\004\151\006\225\000\238\001\018\001&\0007\002\167\007@\002\011\002-\003y\006\226\007_\002\176\001#\005\006\002\177\0023\002d\000\238\002\169\000\235\002P\002\170\006\219\001\243\002`\002a\001j\001\031\003y\007\209\002\191\001C\001\142\002\172\003y\002\015\000\238\002\011\002\022\002\133\006\220\000\235\001\244\006\222\001 \000\238\006\184\002\138\006\241\002U\001\018\001&\006\223\006\246\002\193\003y\007?\002\\\006\229\001\026\002\161\004h\001\027\006\231\005K\001=\002\024\004z\001\197\002\022\001\018\002\176\000\235\002l\002\177\002z\000\238\006\233\006\012\004\172\005\007\002\170\006\224\001\203\000\238\001B\001\029\002\130\001\214\000\238\002\191\001\236\001\142\002\172\002\136\006\234\002\165\0012\001\238\001\211\005\"\003y\001\242\002\023\001\018\001(\005/\002\181\001)\001\224\001\012\001*\001+\001M\002\193\001\012\001\018\001&\000\238\006\225\005\235\001\018\001&\002\011\002\167\005\169\000\238\0052\000\235\006\226\001\026\002\187\001#\001\027\002\023\002\196\002d\001,\002\169\000\235\0016\001\226\000\238\001\243\000\238\007\017\004\172\001\031\005\236\006-\005\237\001C\002\012\006\249\006\219\002\022\000\238\001\029\000\235\001\241\006\162\002\207\001\244\000\238\001 \000\238\001\026\002\213\006\241\001\027\001\018\001&\006\220\005:\002\219\006\222\000\238\002\225\006\229\006\145\005\238\002\231\000\235\006\231\006\223\002\002\001\026\004c\006\137\002\237\003y\002\176\001\214\001\029\002\177\001\246\001\026\006\233\002\243\005\212\000\238\002\170\001\238\001#\000\238\004_\001\242\002#\001\018\006\188\002\191\006\015\001\142\002\172\006\224\006\234\005\239\0012\001\031\002&\002\023\003y\003y\001\029\002\011\001(\005\240\005\241\001)\005\242\000\238\001*\001+\001M\002\193\001 \000\238\002\249\002)\001#\002\255\001\018\001&\000\238\002,\001\026\000\238\001\243\001\027\0022\000\238\006\225\006.\002m\001\031\006\018\002\022\001,\000\238\000\235\0016\006\226\005>\002>\003y\002;\001\244\000\238\003\005\005\214\002A\001 \001\029\003\011\001\031\003\017\005\244\001\018\001&\003\023\003\029\005\246\006\000\006\169\001\031\006\227\000\235\002L\0012\002O\006\015\001 \003#\005L\005]\006*\001(\001\018\001&\001)\006\228\001 \001*\001+\006/\003y\000\238\001\018\005\217\000\238\006\229\002T\003)\006+\003/\006\231\0035\007)\001#\006\022\006\023\002\023\003;\006\162\0012\003y\002[\001\026\001,\006\233\001\027\0016\001(\001\031\007N\001)\005a\000\238\001*\001+\006\024\006(\000\238\003A\000\238\006 \004\172\006\234\000\238\000\238\001 \002k\001(\003E\001\029\001)\001\018\001&\001*\001+\001\026\000\238\001(\001\027\001,\005\218\002y\0016\001*\001+\000\231\002\129\006\015\000\235\000\236\002\135\003\156\005\148\005\165\001\026\005\223\000\238\005\220\000\238\001;\000\238\003\165\001\029\002\148\002\164\003\174\000\238\001\214\003|\001,\001\248\002\190\005\180\006\022\006\023\001#\006\155\001\238\0012\002\180\006\015\001\242\002\186\001\018\003\184\002\195\001(\000\238\003\193\001)\001\031\007\\\001*\001+\006\024\006(\002\206\000\238\003\202\006 \004\172\007\025\007\026\003\213\003\222\002\212\001\026\001 \001#\001\027\006\157\003\231\001=\001\018\001&\007\027\007\028\003\238\001,\002\011\000\238\0016\001\243\001\031\002\218\002\224\006\158\007\029\004\172\002\230\000\238\006\160\001>\001\029\000\238\006\161\004=\001\026\002\236\001V\001 \001\244\001\031\004B\004I\002\242\001\018\001&\004j\002\248\004R\002\022\004\\\000\238\000\235\006\022\006\023\000\238\001\026\001 \0012\001\027\003y\002\254\001=\001\018\001&\000\238\001(\004i\004o\001)\000\238\000\238\001*\001+\006\024\006(\003\004\001#\000\238\006 \004\172\003\n\001>\001\029\000\238\003\016\006\022\006\023\004~\001T\004\143\0012\001\031\003\022\004\145\004\169\001C\003\028\001,\001(\004\174\0016\001)\000\238\003\"\001*\001+\007J\007K\001 \000\238\000\238\006 \004\172\002\023\001\018\001&\000\238\001(\000\238\004\186\001)\003y\001\031\001*\001+\003(\001\026\003.\001#\001\027\001,\005\184\001=\0016\0034\000\238\000\238\003:\001\026\001 \004\195\001\027\003@\001\031\001=\001\018\001&\001C\0077\001.\003y\003K\001>\001\029\002\011\002\011\000\238\003R\000\238\001?\001 \0012\000\238\000\238\001>\001\029\001\018\001&\000\238\001(\004\210\001R\001)\003r\003y\001*\001+\001M\003\155\002`\002a\001j\003\164\004r\004v\004\236\002\022\002\022\000\238\000\235\000\235\004\242\000\231\005\224\002\133\000\235\000\236\004\249\004\255\001#\001(\001,\002\138\001)\0016\003\173\001*\001+\004\n\000\238\003\183\001#\003\192\0012\001\031\002\161\000\231\003y\001C\000\235\000\236\001(\005\232\006\155\001)\003\201\001\031\001*\001+\001M\001C\001 \0073\002\011\005\018\003\212\005\023\001\018\001&\000\238\002`\002a\001j\001 \005&\002\011\005\245\006\155\005.\001\018\001&\002\023\002\023\001,\000\238\002\133\0016\006\157\003\221\003y\000\238\003\230\004\196\002\138\0051\002\022\000\238\000\238\000\235\007\147\003\237\004\021\000j\006\158\004\237\004\029\002\161\002\022\006\160\002\167\000\235\006\157\006\171\004*\0012\004<\002`\002a\001j\005\253\0058\002d\001(\002\169\000\235\001)\0012\006\158\001*\001+\001M\002\133\006\160\000\238\001(\000\238\006\187\001)\005<\002\138\001*\001+\001M\000\238\005B\007\007\007\149\000\238\001\214\005H\004A\002\018\002\161\002\173\001,\004H\004Q\0016\001\238\004[\002\023\006\020\001\242\000\238\001\018\005S\001,\005f\004a\0016\002\167\003y\002\023\002`\002a\001j\002\176\001\214\004n\002\177\002o\005k\002d\005p\002\169\000\235\002\170\001\238\002\133\000\238\003y\001\242\002\011\001\018\005z\002\191\002\138\001\142\002\172\003y\003y\005\128\004\205\001\243\003y\004p\003y\000\238\005\139\002\161\002`\002a\001j\000\238\002\173\005\150\002\167\004}\000\238\002\193\004\168\005\019\001\244\005\168\002\022\002\133\004\176\000\235\002d\004\185\002\169\000\235\001\243\002\138\000\238\004\194\000\238\002\176\005\154\004\179\002\177\004\203\005\175\006E\003y\004\209\002\161\002\170\003y\005\191\000\238\001\244\000\238\004\248\005\201\003y\002\191\003y\001\142\002\172\002\173\005\226\006h\000\238\005\248\004\241\006\002\002`\002a\001j\000\238\006\130\006\141\002\167\003F\001j\006\175\000\238\006\185\006\014\002\193\003y\002\133\002\176\000\238\002d\002\177\002\169\000\235\002\023\002\138\006\"\000\238\002\170\003b\001z\004g\001m\001n\0062\0068\006<\002\191\002\161\001\142\002\172\004\243\000\238\004\246\006X\002\167\000\238\001\026\002`\002a\001j\006\189\002\173\000\238\003y\006\193\006\128\002d\000\238\002\169\000\235\002\193\006\197\002\133\006\209\000\238\001\214\006\186\000\238\004t\000\238\002\138\003g\003s\003t\002\176\001\238\004M\002\177\003y\001\242\006\133\001\018\000\238\002\161\002\170\005\005\006\172\006\216\002\173\004\251\005\004\003y\003y\002\191\000\238\001\142\002\172\005\000\005\003\005\017\005\022\002\167\000\238\000\238\000\238\005!\006\138\001\130\002`\002a\001j\002\176\000\238\002d\002\177\002\169\000\235\002\193\005 \001s\001\243\002\170\000\235\002\133\000\238\006\230\005%\003y\006\168\006\144\002\191\002\138\001\142\002\172\001\031\000\238\006\152\0049\006\191\001\244\006\211\0050\005;\0057\002\161\002\173\005G\002\167\005A\000\238\006\237\001 \003w\003x\002\193\000\238\006\219\001\018\001&\002d\0072\002\169\000\235\006\247\007%\002`\002a\001j\002\176\000\231\007\020\002\177\000\235\000\236\006\220\000\238\005C\006\222\002\170\005Z\002\133\005N\007 \005Y\001\132\007.\006\223\002\191\002\138\001\142\002\172\002\173\003y\001\133\0041\001\142\001q\000\238\000\238\007P\006\155\002\161\0070\005T\003y\000\238\005X\000\238\002\167\000\238\001\026\002\193\001(\001\027\002\176\001)\006\224\002\177\001*\001+\002d\003y\002\169\000\235\002\170\002`\002a\001j\005e\003y\005j\005\200\003y\002\191\006\157\001\142\002\172\001\029\005o\000\238\002\133\005r\005v\005~\0073\002`\002a\001j\002\138\005\133\006\158\000\238\002\173\006\225\000\238\006\160\005\144\002\193\005\199\006\205\002\133\002\161\005\192\006\226\007^\002\167\005\193\005\198\002\138\005\202\005\203\000\238\005\234\005\227\004'\002\176\007i\002d\002\177\002\169\000\235\002\161\005\228\001#\005\233\002\170\005\255\006\238\005\251\005\252\005\254\006)\001\026\007\196\002\191\001\027\001\142\002\172\001\031\006\r\001\214\007\207\006\228\004\199\007\212\002`\002a\001j\006\017\002\173\001\238\006\019\006\229\006\021\001\242\001 \001\018\006\231\002\193\001\029\002\133\001\018\001&\006!\0061\002\167\0063\0064\002\138\0069\006=\006\233\002\176\006A\003\255\002\177\006S\002d\006Z\002\169\000\235\002\161\002\170\006^\006v\002\167\006\139\006\163\006\173\006\234\006\218\002\191\006\212\001\142\002\172\001\243\006\213\002d\006\217\002\169\000\235\006\232\002`\002a\001j\001#\007\015\007#\001<\002\173\007$\007(\007O\007S\001\244\002\193\001(\002\133\007]\001)\001\031\007a\001*\001+\007\182\002\138\000\000\000\000\000\000\002\173\000\000\002\159\003_\000\000\000\000\002\177\0040\001 \002\161\000\000\000\000\000\000\002\170\001\018\001&\002\167\000\000\000\000\001,\000\000\000\000\002\191\002\176\001\142\002\172\002\177\000\000\002d\000\000\002\169\000\235\000\000\002\170\002`\002a\001j\000\000\000\000\000\000\000\000\000\000\002\191\000\000\001\142\002\172\002\193\000\000\000\000\002\133\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\138\000\000\000\000\002\173\001'\000\000\002\175\000\000\000\000\002\193\000\000\000\000\001(\002\161\000\000\001)\002\167\000\000\001*\001+\000\000\000\000\000\000\002`\002a\001j\002\176\000\000\002d\002\177\002\169\000\235\000\000\000\000\001i\001j\002\170\000\000\002\133\000\000\000\000\000\000\000\000\003W\001,\002\191\002\138\001\142\002\172\000\000\000\000\003Z\002\203\000\000\001k\002E\000\000\001m\001n\002\161\002\173\002`\002a\001j\000\000\001\214\000\000\000\000\004\214\002\193\000\000\000\000\000\000\000\000\000\000\001\238\002\133\002\167\000\000\001\242\000\000\001\018\002F\002\176\002\138\001\214\002\177\000\000\004\217\002d\002\202\002\169\000\235\002\170\000\000\001\238\000\000\002\161\000\000\001\242\001\214\001\018\002\191\004\220\001\142\002\172\000\000\000\000\000\000\000\000\001\238\000\000\000\000\000\000\001\242\000\000\001\018\000\000\001\026\000\000\001\243\002\173\000\000\002\167\000\000\000\000\002\193\000\000\000\000\000\000\000\000\000\000\000\000\001r\000\000\002d\000\000\002\169\000\235\001\244\001\243\002`\002a\001j\002\176\001s\000\000\002\177\000\235\000\000\000\000\000\000\000\000\000\000\002\170\001\243\002\133\000\000\000\000\001\244\000\000\002\167\000\000\002\191\002\138\001\142\002\172\002\173\001i\001j\003H\000\000\000\000\002d\001\244\002\169\000\235\002\161\000\000\000\000\002G\000\000\000\000\000\000\000\000\004\183\000\000\002\193\001k\002E\002\176\001m\001n\002\177\000\000\000\000\000\000\000\000\000\000\000\000\002\170\003[\003a\000\000\000\000\002\173\001\031\000\000\000\000\002\191\001\132\001\142\002\172\000\000\000\000\000\000\002F\000\000\000\000\001\141\000\000\001\142\001q\001 \000\000\002`\002a\001j\002\176\001\018\001&\002\177\0075\002\193\000\000\000\000\000\000\000\000\002\170\000\000\002\133\002\167\000\000\000\000\000\000\000\000\000\000\002\191\002\138\001\142\002\172\000\000\000\000\002d\003O\002\169\000\235\000\000\000\000\000\000\000\000\002\161\000\000\002`\002a\001j\000\000\001r\000\000\000\000\000\000\002\193\000\000\000\000\000\000\000\000\000\000\000\000\002\133\001s\001i\001j\000\235\000\000\001(\002\173\002\138\001)\000\000\000\000\001*\001+\003V\000\000\000\000\000\000\000\000\006f\000\000\002\161\001k\002E\000\000\001m\001n\000\000\000\000\000\000\002\176\000\000\001\214\002\177\000\000\004\225\002G\000\000\0073\000\000\002\170\000\000\001\238\000\000\000\000\000\000\001\242\002\167\001\018\002\191\002F\001\142\002\172\002`\002a\001j\000\000\003[\003a\002d\000\000\002\169\000\235\000\000\000\000\000\000\001\132\000\000\002\133\000\000\000\000\000\000\000\000\002\193\000\000\001\141\002\138\001\142\001q\000\000\000\000\000\000\003Y\000\000\000\000\002\167\000\000\001\243\000\000\002\161\000\000\002\173\000\000\000\000\000\000\000\000\000\000\002d\000\000\002\169\000\235\001r\000\000\002`\002a\001j\001\244\000\000\000\000\000\000\000\000\000\000\000\000\001s\002\176\000\000\000\235\002\177\002\133\000\000\000\000\000\000\000\000\000\000\002\170\000\000\002\138\000\000\000\000\002\173\000\000\001\214\000\000\002\191\004\228\001\142\002\172\000\000\000\000\002\161\000\000\001\238\000\000\000\000\000\000\001\242\000\000\001\018\002G\000\000\000\000\000\000\002\176\002\167\000\000\002\177\000\000\002\193\000\000\000\000\000\000\006\219\002\170\000\000\000\000\002d\000\000\002\169\000\235\003[\003a\002\191\000\000\001\142\002\172\000\000\007\202\000\000\001\132\007\203\000\000\000\000\006\222\002`\002a\001j\001\243\001\141\000\000\001\142\001q\006\223\000\000\000\000\000\000\002\193\000\000\002\173\002\133\000\000\000\000\000\000\000\000\002\167\000\000\001\244\002\138\000\000\000\000\000\000\000\000\000\000\003f\000\000\000\000\002d\000\000\002\169\000\235\002\161\002\176\006\224\000\000\002\177\000\000\002`\002a\001j\000\000\000\000\002\170\002`\002a\001j\000\000\001\214\000\000\000\000\004\231\002\191\000\000\001\142\002\172\000\000\000\000\001\238\002\133\002\173\004\024\001\242\000\000\001\018\000\000\000\000\002\138\004 \000\000\000\000\006\225\000\000\003i\001\214\000\000\002\193\004\245\000\000\000\000\002\161\006\226\000\000\003_\001\238\000\000\002\177\003`\001\242\000\000\001\018\000\000\004X\002\170\001i\001j\002\167\000\000\002`\002a\001j\007\205\002\191\001\243\001\142\002\172\000\000\000\000\002d\001\214\002\169\000\235\005E\002\133\001k\002E\000\000\001m\001n\001\238\006\228\002\138\001\244\001\242\000\000\001\018\002\193\003\127\000\000\001\243\006\229\000\000\000\000\000\000\002\161\006\231\000\000\000\000\002c\000\000\002\173\000\000\002F\000\000\002\167\002`\002a\001j\001\244\006\233\004#\000\000\002\169\000\235\000\255\000\000\002d\000\000\002\169\000\235\002\133\000\000\000\000\002\176\001\243\000\000\002\177\006\234\002\138\000\000\000\000\000\000\000\000\002\170\003\130\000\000\000\000\000\000\000\000\000\000\000\000\002\161\002\191\001\244\001\142\002\172\000\000\004\027\002\173\000\000\000\000\000\000\000\000\001r\000\000\000\000\000\000\000\000\002\167\000\000\000\000\000\000\002`\002a\001j\001s\002\193\000\000\000\235\000\000\002d\002\176\002\169\000\235\002\177\002\170\000\000\002\133\000\000\000\000\000\000\002\170\000\000\000\000\002\171\002\138\001\142\002\172\000\000\000\000\002\191\003\179\001\142\002\172\000\000\000\000\000\000\000\000\002\161\000\000\002G\000\000\002\173\000\000\000\000\002\167\000\000\000\000\000\000\002`\002a\001j\000\000\006\219\002\193\000\000\000\000\002d\000\000\002\169\000\235\002I\003a\000\000\002\133\002\176\000\000\000\000\002\177\000\000\001\132\006\220\002\138\000\000\006\222\002\170\000\000\000\000\003\188\001\141\000\000\001\142\001q\006\223\002\191\002\161\001\142\002\172\000\000\002\173\000\000\000\000\000\000\000\000\000\000\000\000\002`\002a\001j\000\000\000\000\000\000\002\167\000\000\000\000\000\000\000\000\000\000\002\193\000\000\000\000\002\133\002\176\006\224\002d\002\177\002\169\000\235\000\000\002\138\000\000\000\000\002\170\000\000\000\000\003\197\000\000\000\000\000\000\000\000\000\000\002\191\002\161\001\142\002\172\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002`\002a\001j\000\000\002\173\000\000\000\000\002\167\006\225\000\000\000\000\000\000\000\000\002\193\000\000\002\133\000\000\000\000\006\226\002d\000\000\002\169\000\235\002\138\000\000\001\026\000\000\002\176\0079\004\002\002\177\000\000\000\000\000\000\000\000\000\000\002\161\002\170\000\000\001i\001j\000\000\006\248\000\000\000\000\000\000\002\191\000\000\001\142\002\172\000\000\002\173\001\029\000\000\002\167\000\000\000\000\006\228\000\000\001k\001z\000\000\001m\001n\000\000\000\000\002d\006\229\002\169\000\235\002\193\000\000\006\231\000\000\002\176\000\000\000\000\002\177\000\000\000\000\000\000\000\000\002V\000\000\002\170\000\000\006\233\002`\002a\001j\000\000\000\000\000\000\002\191\000\000\001\142\002\172\000\000\002\173\000\000\002\167\000\000\002\133\001{\006\234\001|\002/\000\000\000\000\000\000\002\138\000\000\002d\001\031\002\169\000\235\004\005\002\193\002`\002a\001j\002\176\000\000\002\161\002\177\000\000\000\000\000\000\000\000\000\000\001 \002\170\000\000\002\133\000\000\000\000\001\018\001&\001\130\000\000\002\191\002\138\001\142\002\172\002\173\000\000\000\000\004+\000\000\000\000\001s\000\000\000\000\000\235\002\161\000\000\002`\002a\001j\000\000\000\000\002Y\000\000\000\000\002\193\000\000\001\214\002\176\000\000\005P\002\177\002\133\000\000\000\000\000\000\000\000\001\238\002\170\000\000\002\138\001\242\000\000\001\018\000\000\000\000\004-\002\191\002\167\001\142\002\172\000\000\001(\002\161\000\000\001)\000\000\000\000\001*\001+\002d\000\000\002\169\000\235\000\000\001\026\002`\002a\001j\000\000\000\000\002\193\000\000\000\000\000\000\000\000\001\132\000\000\000\000\002\167\000\000\002\133\001\243\000\000\001,\001\133\000\000\001\142\001q\002\138\000\000\002d\002\173\002\169\000\235\0043\000\000\002`\002a\001j\001\214\001\244\002\161\005V\000\000\000\000\000\000\000\000\000\000\000\000\001\238\000\000\002\133\000\000\001\242\002\176\001\018\002\167\002\177\000\000\002\138\000\000\000\000\002\173\000\000\002\170\0046\000\000\000\000\002d\000\000\002\169\000\235\002\161\002\191\000\000\001\142\002\172\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\176\000\000\000\000\002\177\000\000\000\000\000\000\001\031\000\000\001\243\002\170\000\000\002\193\000\000\000\000\002\173\000\000\000\000\000\000\002\191\002\167\001\142\002\172\000\000\001 \000\000\000\000\000\000\001\244\000\000\001\018\001&\002d\000\000\002\169\000\235\000\000\000\000\002\176\000\000\000\000\002\177\000\000\002\193\000\000\000\000\001\026\000\000\002\170\001\027\000\000\002\167\000\000\002`\002a\001j\000\000\002\191\000\000\001\142\002\172\000\000\000\000\002d\002\173\002\169\000\235\000\000\002\133\000\000\000\000\000\000\000\000\001\029\000\000\005\235\002\138\000\000\002`\002a\001j\002\193\004l\000\000\000\000\001(\000\000\002\176\001)\002\161\002\177\001*\001+\002\133\000\000\002\173\000\000\002\170\000\000\000\000\000\000\002\138\000\000\005\236\000\000\005\237\002\191\004y\001\142\002\172\000\000\000\000\000\000\000\000\002\161\000\000\000\000\002K\002\176\001#\000\000\002\177\001\214\000\000\000\000\005_\000\000\000\000\002\170\000\000\002\193\000\000\001\238\000\000\001\031\005\238\001\242\002\191\001\018\001\142\002\172\000\000\000\000\000\000\000\000\000\000\000\000\002`\002a\001j\000\000\001 \000\000\002\167\000\000\000\000\000\000\001\018\001&\000\000\000\000\002\193\002\133\000\000\000\000\002d\000\000\002\169\000\235\000\000\002\138\005\239\002`\002a\001j\000\000\004\171\001\243\002\167\000\000\000\000\005\240\005\241\002\161\005\242\000\000\000\000\002\133\000\000\000\000\002d\000\000\002\169\000\235\000\000\002\138\001\244\002\173\000\000\000\000\000\000\005\r\000\000\000\000\007;\000\000\000\000\006,\002\161\000\000\000\000\000\000\001(\000\000\000\000\001)\000\000\000\000\001*\001+\002\176\000\000\002\173\002\177\000\000\000\000\000\000\000\000\000\000\000\000\002\170\005\244\000\000\000\000\000\000\000\000\005\246\006\000\000\000\002\191\000\000\001\142\002\172\000\000\001,\002\176\000\000\002\167\002\177\000\000\006*\000\000\000\000\000\000\000\000\002\170\002`\002a\001j\002d\000\000\002\169\000\235\002\193\002\191\000\000\001\142\002\172\006+\000\000\000\000\002\133\002\167\000\000\000\000\000\000\000\000\000\000\000\000\002\138\000\000\000\000\000\000\000\000\002d\006@\002\169\000\235\002\193\000\000\000\000\002\173\002\161\000\000\000\000\000\000\000\000\000\000\000\000\001\214\000\000\000\000\005g\000\000\000\000\002`\002a\001j\000\000\001\238\000\000\000\000\000\000\001\242\002\176\001\018\002\173\002\177\000\000\000\000\002\133\000\000\000\000\000\000\002\170\000\000\000\000\000\000\002\138\000\000\000\000\000\000\000\000\002\191\006C\001\142\002\172\000\000\000\000\002\176\000\000\002\161\002\177\000\000\000\000\000\000\000\000\000\000\000\000\002\170\000\000\000\000\000\000\000\000\001\243\000\000\002\167\002\193\002\191\000\000\001\142\002\172\002`\002a\001j\000\000\000\000\000\000\002d\000\000\002\169\000\235\000\000\001\244\006\219\000\000\000\000\002\133\000\000\000\000\000\000\000\000\002\193\000\000\000\000\002\138\001i\001j\000\000\007\202\000\000\006R\007\203\000\000\000\000\006\222\000\000\000\000\002\161\000\000\002\173\000\000\000\000\000\000\006\223\002\167\001k\001z\000\000\001m\001n\000\000\002`\002a\001j\000\000\000\000\002d\000\000\002\169\000\235\000\000\000\000\002\176\000\000\000\000\002\177\002\133\000\000\002\131\000\000\000\000\000\000\002\170\006\224\002\138\000\000\000\000\000\000\000\000\000\000\006U\002\191\000\000\001\142\002\172\000\000\000\000\002\161\002\173\001{\000\000\001|\002/\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\167\002`\002a\001j\002\193\000\000\000\000\000\000\000\000\006\225\002\176\000\000\002d\002\177\002\169\000\235\002\133\000\000\000\000\006\226\002\170\000\000\000\000\001\130\002\138\000\000\000\000\000\000\000\000\002\191\006b\001\142\002\172\000\000\000\000\001s\000\000\002\161\000\235\007\204\002`\002a\001j\000\000\002\173\000\000\002Y\000\000\000\000\000\000\002\167\000\000\000\000\002\193\000\000\002\133\000\000\000\000\006\228\000\000\000\000\000\000\002d\002\138\002\169\000\235\000\000\002\176\006\229\006e\002\177\000\000\000\000\006\231\000\000\000\000\002\161\002\170\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\191\006\233\001\142\002\172\000\000\000\000\000\000\000\000\002\173\000\000\000\000\000\000\001i\001j\001\132\002\167\000\000\000\000\000\000\006\234\000\000\000\000\000\000\001\133\002\193\001\142\001q\002d\000\000\002\169\000\235\002\176\001k\002E\002\177\001m\001n\000\000\000\000\000\000\000\000\002\170\000\000\000\000\000\000\000\000\000\000\002`\002a\001j\002\191\000\000\001\142\002\172\002\167\000\000\000\000\000\000\000\000\002\173\000\000\000\000\002\133\000\000\000\000\000\000\002d\000\000\002\169\000\235\002\138\000\000\000\000\000\000\002\193\000\000\006z\000\000\000\000\000\000\000\000\000\000\002\176\002\161\000\000\002\177\000\000\000\000\000\000\000\000\000\000\000\000\002\170\002`\002a\001j\000\000\000\000\002\173\000\000\000\000\002\191\000\000\001\142\002\172\000\000\000\000\000\000\002\133\000\000\000\000\001r\000\000\000\000\001\026\000\000\002\138\001\027\000\000\000\000\000\000\002\176\006}\001s\002\177\002\193\000\235\000\000\000\000\002\161\000\000\002\170\000\000\000\000\002`\002a\001j\000\000\000\000\000\000\002\191\001\029\001\142\002\172\000\000\000\000\000\000\002\167\000\000\002\133\000\000\005\026\000\000\000\000\002`\002a\001j\002\138\006\206\002d\000\000\002\169\000\235\006\129\002\193\000\000\000\000\007h\000\000\002\133\002\161\000\000\000\000\000\000\000\000\000\000\000\000\002\138\000\000\000\000\000\000\000\000\000\000\007m\000\000\000\000\000\000\001#\001\132\000\000\002\161\002\173\000\000\002\167\000\000\000\000\000\000\001\141\000\000\001\142\001q\000\000\001\031\000\000\000\000\002d\000\000\002\169\000\235\000\000\000\000\006\208\000\000\000\000\002\176\000\000\000\000\002\177\000\000\001 \000\000\000\000\000\000\000\000\002\170\001\018\001&\000\000\000\000\000\000\000\000\000\000\000\000\002\191\002\167\001\142\002\172\002\173\002`\002a\001j\000\000\000\000\000\000\000\000\000\000\002d\000\000\002\169\000\235\000\000\000\000\000\000\002\133\002\167\000\000\000\000\002\193\000\000\000\000\002\176\002\138\000\000\002\177\000\000\000\000\002d\007o\002\169\000\235\002\170\000\000\0012\000\000\002\161\000\000\000\000\000\000\002\173\002\191\001(\001\142\002\172\001)\000\000\000\000\001*\001+\005#\001\026\000\000\000\000\001$\000\000\000\000\000\000\000\000\000\000\002\173\000\000\000\000\002\176\000\000\002\193\002\177\001i\001j\000\000\000\000\000\000\000\000\002\170\001,\000\000\000\000\0016\001\029\000\000\000\000\000\000\002\191\002\176\001\142\002\172\002\177\001k\002E\000\000\001m\001n\000\000\002\170\002`\002a\001j\000\000\000\000\000\000\002\167\000\000\002\191\000\000\001\142\002\172\002\193\000\000\000\000\002\133\000\000\000\000\002d\000\000\002\169\000\235\000\000\002\138\000\000\002`\002a\001j\000\000\000\000\000\000\000\000\002\193\004\190\000\000\000\000\002\161\000\000\000\000\000\000\002\133\000\000\000\000\000\000\000\000\001\031\000\000\000\000\002\138\000\000\002\173\000\000\002`\002a\001j\000\000\000\000\000\000\004e\000\000\000\000\002\161\001 \000\000\000\000\000\000\000\000\002\133\001\018\001&\000\000\000\000\001r\002\176\000\000\002\138\002\177\000\000\000\000\000\000\000\000\000\000\000\000\002\170\001s\003\247\000\000\000\235\002\161\000\000\000\000\000\000\002\191\000\000\001\142\002\172\000\000\000\000\000\000\000\000\002\167\000\000\000\000\000\000\000\000\002`\002a\001j\000\000\000\000\000\000\000\000\002d\000\000\002\169\000\235\002\193\000\000\000\000\006\206\002\133\000\000\000\000\001(\000\000\002\167\001)\000\000\002\138\001*\001+\000\000\000\000\001i\001j\000\000\000\000\002d\003\246\002\169\000\235\002\161\000\000\000\000\002\173\000\000\000\000\000\000\000\000\001\132\000\000\000\000\002\167\001k\001z\001,\001m\001n\001\141\000\000\001\142\001q\000\000\000\000\002d\000\000\002\169\000\235\000\000\002\173\003\137\000\000\006\207\000\000\000\000\000\000\002\137\002\170\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\191\000\000\001\142\002\172\000\000\000\000\000\000\000\000\000\000\003\137\002\173\001{\000\000\001|\002/\000\000\002\170\001i\001j\002\167\000\000\000\000\000\000\000\000\002\193\002\191\000\000\001\142\002\172\000\000\000\000\002d\000\000\002\169\000\235\000\000\003\137\001k\001z\000\000\001m\001n\000\000\002\170\000\000\000\000\001\130\001i\001j\002\193\000\000\000\000\002\191\000\000\001\142\002\172\000\000\000\000\001s\000\000\002\166\000\235\000\000\002\173\000\000\000\000\000\000\001k\001z\002Y\001m\001n\000\000\000\000\001i\001j\002\193\000\000\000\000\000\000\000\000\001{\000\000\001|\002/\000\000\000\000\000\000\000\000\003\137\002\182\000\000\000\000\000\000\001k\001z\002\170\001m\001n\000\000\000\000\000\000\000\000\000\000\000\000\002\191\000\000\001\142\002\172\000\000\000\000\001{\000\000\001|\002/\000\000\001\130\002\188\000\000\000\000\000\000\000\000\000\000\001\132\000\000\000\000\000\000\000\000\001s\002\193\000\000\000\235\001\133\000\000\001\142\001q\000\000\000\000\001{\002Y\001|\002/\000\000\001i\001j\000\000\001\130\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001s\000\000\000\000\000\235\000\000\001k\001z\000\000\001m\001n\000\000\002Y\000\000\000\000\000\000\001\130\001i\001j\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001s\002\197\000\000\000\235\000\000\000\000\001i\001j\001\132\001k\001z\002Y\001m\001n\000\000\000\000\000\000\001\133\000\000\001\142\001q\000\000\001{\000\000\001|\002/\001k\002E\000\000\001m\001n\000\000\002\208\000\000\000\000\000\000\000\000\000\000\001\132\000\000\001i\001j\000\000\000\000\000\000\000\000\000\000\001\133\000\000\001\142\001q\000\000\000\000\001{\000\000\001|\002/\001\130\001i\001j\001k\001z\000\000\001m\001n\001\132\000\000\000\000\000\000\001s\000\000\000\000\000\235\000\000\001\133\000\000\001\142\001q\001k\001z\002Y\001m\001n\002\214\000\000\000\000\000\000\000\000\001\130\001i\001j\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001s\002\220\000\000\000\235\001{\001r\001|\002/\000\000\001k\001z\002Y\001m\001n\000\000\000\000\000\000\001s\000\000\000\000\000\235\000\000\001{\000\000\001|\002/\000\000\000\000\000\000\000\000\000\000\000\000\002\226\000\000\001\132\000\000\000\000\000\000\000\000\001\130\001i\001j\000\000\001\133\000\000\001\142\001q\000\000\000\000\000\000\000\000\001s\006\206\001{\000\235\001|\002/\001\130\000\000\000\000\001k\001z\002Y\001m\001n\001\132\000\000\000\000\000\000\001s\000\000\000\000\000\235\000\000\001\133\000\000\001\142\001q\000\000\000\000\002Y\000\000\001\132\002\232\000\000\000\000\000\000\000\000\001\130\001i\001j\001\141\000\000\001\142\001q\000\000\000\000\000\000\000\000\000\000\001s\000\000\000\000\000\235\001{\006\215\001|\002/\000\000\001k\001z\002Y\001m\001n\000\000\000\000\001\132\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\133\000\000\001\142\001q\000\000\000\000\000\000\002\238\000\000\001\132\000\000\000\000\000\000\000\000\001\130\001i\001j\000\000\001\133\000\000\001\142\001q\000\000\000\000\000\000\000\000\001s\000\000\001{\000\235\001|\002/\000\000\000\000\000\000\001k\001z\002Y\001m\001n\001\132\000\000\000\000\000\000\001i\001j\000\000\000\000\000\000\001\133\000\000\001\142\001q\000\000\000\000\000\000\000\000\000\000\002\244\000\000\000\000\000\000\000\000\001\130\001k\001z\000\000\001m\001n\000\000\000\000\000\000\001i\001j\000\000\001s\000\000\000\000\000\235\001{\000\000\001|\002/\000\000\000\000\000\000\002Y\002\250\000\000\000\000\000\000\001\132\001k\001z\000\000\001m\001n\000\000\000\000\000\000\001\133\000\000\001\142\001q\000\000\000\000\000\000\000\000\001{\000\000\001|\002/\000\000\000\000\001\130\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001s\000\000\000\000\000\235\000\000\000\000\000\000\000\000\000\000\000\000\001{\002Y\001|\002/\001\132\001i\001j\001\130\000\000\000\000\000\000\000\000\000\000\001\133\000\000\001\142\001q\000\000\000\000\001s\000\000\000\000\000\235\000\000\000\000\001k\001z\000\000\001m\001n\002Y\000\000\000\000\001i\001j\001\130\000\000\000\000\000\000\001i\001j\000\000\000\000\000\000\000\000\000\000\000\000\001s\003\006\000\000\000\235\000\000\000\000\001k\001z\001\132\001m\001n\002Y\001k\001z\000\000\001m\001n\001\133\000\000\001\142\001q\000\000\001{\000\000\001|\002/\000\000\000\000\000\000\003\012\000\000\000\000\000\000\000\000\000\000\003\018\000\000\001\132\000\000\000\000\000\000\000\000\000\000\001i\001j\000\000\001\133\000\000\001\142\001q\001{\000\000\001|\002/\000\000\000\000\001{\001\130\001|\002/\000\000\000\000\000\000\001k\001z\001\132\001m\001n\000\000\001s\000\000\000\000\000\235\000\000\001\133\000\000\001\142\001q\000\000\000\000\002Y\000\000\000\000\000\000\000\000\001\130\003\024\000\000\000\000\000\000\000\000\001\130\001i\001j\000\000\000\000\000\000\001s\000\000\000\000\000\235\000\000\000\000\001s\000\000\000\000\000\235\001{\002Y\001|\002/\000\000\001k\001z\002Y\001m\001n\000\000\000\000\000\000\000\000\000\000\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\132\003\030\000\000\000\000\000\000\000\000\000\000\000\000\001\130\001\133\000\000\001\142\001q\001\026\000\000\000\000\000\000\000\000\000\000\000\000\001s\000\000\001{\000\235\001|\002/\000\000\000\000\001\132\000\000\000\000\002Y\000\000\000\000\001\132\000\000\000\000\001\133\000\000\001\142\001q\001i\001j\001\133\000\000\001\142\001q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001i\001j\001\130\000\000\000\000\000\000\001k\001z\000\000\001m\001n\000\000\000\000\000\000\001s\000\000\000\000\000\235\000\000\000\000\001k\001z\000\000\001m\001n\002Y\000\000\000\000\000\000\003$\001\132\000\000\000\000\000\000\000\000\000\000\000\000\001i\001j\001\133\000\000\001\142\001q\003*\000\000\000\000\001\031\000\000\000\000\000\000\001{\000\000\001|\002/\000\000\000\000\000\000\001k\001z\000\000\001m\001n\000\000\001 \001{\000\000\001|\002/\000\000\001\018\001&\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\132\0030\001\026\000\000\000\000\000\000\001\130\000\000\000\000\001\133\000\000\001\142\001q\001\026\000\000\000\000\005\208\000\000\001s\000\000\001\130\000\235\001{\000\000\001|\002/\000\000\000\000\000\000\002Y\000\000\000\000\001s\000\000\000\000\000\235\000\000\000\000\001i\001j\001\029\000\000\000\000\002Y\000\000\001(\000\000\000\000\001)\000\000\000\000\001*\001+\000\000\000\000\001i\001j\001\130\001k\001z\000\000\001m\001n\000\000\000\000\000\000\000\000\000\000\000\000\001s\000\000\000\000\000\235\000\000\000\000\001k\001z\004\154\001m\001n\002Y\0036\000\000\001\132\000\000\000\000\000\000\000\000\000\000\000\000\001\031\000\000\001\133\000\000\001\142\001q\000\000\001\132\003<\000\000\000\000\001\031\001{\000\000\001|\002/\001\133\001 \001\142\001q\000\000\000\000\000\000\001\018\001&\002`\002a\001j\001 \001{\000\000\001|\002/\000\000\001\018\001&\000\000\000\000\000\000\000\000\002\133\000\000\000\000\000\000\001\132\001i\001j\001\130\002\138\000\000\000\000\000\000\000\000\001\133\000\000\001\142\001q\000\000\003\135\001s\000\000\002\161\000\235\000\000\001\130\001k\001z\000\000\001m\001n\002Y\002`\002a\001j\000\000\000\000\001s\000\000\001(\000\235\000\000\001)\000\000\000\000\001*\001+\002\133\002Y\003B\001(\000\000\000\000\001)\000\000\002\138\001*\001+\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\139\000\000\000\000\002\161\000\000\001{\004\162\001|\002/\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001,\000\000\000\000\001\132\002\167\000\000\000\000\002`\002a\001j\000\000\000\000\001\133\000\000\001\142\001q\002d\000\000\002\169\000\235\001\132\000\000\002\133\001\130\000\000\000\000\000\000\000\000\000\000\001\133\002\138\001\142\001q\000\000\000\000\001s\000\000\000\000\000\235\000\000\003\141\000\000\000\000\002\161\000\000\000\000\002Y\000\000\002\173\000\000\002\167\000\000\000\000\002`\002a\001j\000\000\000\000\000\000\000\000\000\000\000\000\002d\000\000\002\169\000\235\000\000\000\000\002\133\000\000\000\000\000\000\000\000\000\000\003\137\000\000\002\138\000\000\000\000\000\000\000\000\002\170\000\000\000\000\000\000\000\000\003\144\000\000\000\000\002\161\002\191\000\000\001\142\002\172\002\173\000\000\000\000\000\000\000\000\000\000\001\132\002`\002a\001j\000\000\000\000\000\000\002\167\000\000\001\133\000\000\001\142\001q\000\000\002\193\000\000\002\133\000\000\000\000\002d\003\137\002\169\000\235\000\000\002\138\000\000\000\000\002\170\000\000\000\000\000\000\000\000\000\000\000\000\003\151\000\000\002\191\002\161\001\142\002\172\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002`\002a\001j\000\000\002\173\000\000\002\167\000\000\001i\001j\000\000\000\000\000\000\002\193\000\000\002\133\000\000\000\000\002d\000\000\002\169\000\235\000\000\002\138\000\000\000\000\000\000\000\000\001k\001z\003\137\001m\001n\003\160\000\000\000\000\002\161\002\170\001i\001j\000\000\000\000\000\000\000\000\000\000\000\000\002\191\000\000\001\142\002\172\002\173\003\157\000\000\000\000\002\167\000\000\000\000\000\000\001k\001z\000\000\001m\001n\000\000\000\000\000\000\002d\000\000\002\169\000\235\002\193\000\000\001{\000\000\001|\002/\003\137\000\000\000\000\000\000\000\000\003\166\000\000\002\170\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\191\000\000\001\142\002\172\000\000\000\000\002\173\000\000\002\167\000\000\001{\000\000\001|\002/\000\000\001\130\000\000\000\000\000\000\000\000\002d\000\000\002\169\000\235\002\193\000\000\000\000\001s\000\000\000\000\000\235\000\000\003\137\000\000\000\000\002`\002a\001j\002Y\002\170\002`\002a\001j\000\000\000\000\001\130\001i\001j\002\191\000\000\001\142\002\172\002\173\000\000\000\000\002\133\000\000\001s\003\241\000\000\000\235\000\000\000\000\002\138\000\000\000\000\001k\001z\002Y\001m\001n\000\000\002\193\003\169\000\000\000\000\002\161\000\000\003\137\000\000\000\000\000\000\003\242\000\000\000\000\002\170\000\000\000\000\000\000\003\175\000\000\000\000\001\132\005\235\002\191\000\000\001\142\002\172\000\000\000\000\000\000\001\133\000\000\001\142\001q\001i\001j\000\000\000\000\000\000\001{\000\000\001|\002/\000\000\000\000\000\000\000\000\002\193\000\000\000\000\005\236\001\132\005\237\000\000\001k\001z\000\000\001m\001n\000\000\001\133\000\000\001\142\001q\002c\000\000\000\000\000\000\000\000\002\167\000\000\001i\001j\000\000\001\130\000\000\002d\003\185\002\169\000\235\000\000\002d\005\238\002\169\000\235\000\000\001s\000\000\000\000\000\235\000\000\001k\001z\000\000\001m\001n\000\000\002Y\001{\000\000\001|\002/\000\000\000\000\000\000\000\000\001\026\000\000\000\000\000\000\000\000\000\000\003\244\002\173\003\194\000\000\000\000\000\000\005\239\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\240\005\241\000\000\005\242\000\000\001\130\000\000\001{\000\000\001|\002/\003\137\000\000\002\170\000\000\000\000\000\000\001s\002\170\000\000\000\235\000\000\002\171\001\132\001\142\002\172\005\243\002\191\002Y\001\142\002\172\000\000\001\133\000\000\001\142\001q\000\000\000\000\001i\001j\000\000\000\000\001\130\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\244\002\193\000\000\000\000\001s\005\246\006\000\000\235\001k\001z\000\000\001m\001n\000\000\000\000\002Y\001\031\000\000\000\000\006*\000\000\000\000\000\000\002`\002a\001j\000\000\002`\002a\001j\000\000\003\203\001\132\001 \000\000\000\000\000\000\006+\002\133\001\018\001&\001\133\002\133\001\142\001q\000\000\002\138\001i\001j\000\000\002\138\000\000\001{\000\000\001|\002/\003\208\000\000\000\000\002\161\003\217\000\000\000\000\002\161\000\000\000\000\000\000\001k\001z\001\132\001m\001n\000\000\000\000\000\000\000\000\000\000\000\000\001\133\000\000\001\142\001q\000\000\000\000\000\000\001i\001j\001\130\000\000\000\000\003\214\000\000\000\000\000\000\001(\000\000\000\000\001)\000\000\001s\001*\001+\000\235\000\000\000\000\001k\001z\000\000\001m\001n\002Y\001{\000\000\001|\002/\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\167\000\000\000\000\004\166\002\167\003\223\000\000\002`\002a\001j\000\000\000\000\002d\000\000\002\169\000\235\002d\000\000\002\169\000\235\000\000\000\000\002\133\001\130\000\000\000\000\001{\000\000\001|\002/\002\138\000\000\000\000\000\000\000\000\001s\000\000\000\000\000\235\000\000\003\226\001\132\000\000\002\161\002\173\000\000\002Y\000\000\002\173\000\000\001\133\000\000\001\142\001q\000\000\000\000\000\000\000\000\000\000\001i\001j\001\130\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\137\000\000\000\000\001s\003\137\000\000\000\235\002\170\000\000\001k\001z\002\170\001m\001n\002Y\000\000\002\191\000\000\001\142\002\172\002\191\000\000\001\142\002\172\000\000\000\000\000\000\000\000\000\000\000\000\001\132\000\000\003\232\000\000\000\000\000\000\000\000\002\167\000\000\001\133\002\193\001\142\001q\000\000\002\193\000\000\001i\001j\000\000\002d\000\000\002\169\000\235\001{\000\000\001|\002/\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001k\001z\001\132\001m\001n\000\000\002`\002a\001j\000\000\000\000\001\133\000\000\001\142\001q\002\173\000\000\000\000\000\000\000\000\000\000\002\133\001\130\003\239\000\000\000\000\000\000\000\000\000\000\002\138\000\000\000\000\000\000\000\000\001s\000\000\000\000\000\235\000\000\003\250\000\000\003\137\002\161\000\000\001{\002Y\001|\002/\002\170\002`\002a\001j\000\000\000\000\000\000\000\000\000\000\002\191\000\000\001\142\002\172\000\000\000\000\000\000\002\133\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\138\000\000\000\000\000\000\000\000\000\000\000\000\001\130\000\000\002\193\003\253\000\000\000\000\002\161\002`\002a\001j\000\000\000\000\001s\000\000\000\000\000\235\000\000\000\000\000\000\000\000\001\132\000\000\002\133\002Y\000\000\000\000\000\000\002\167\000\000\001\133\002\138\001\142\001q\000\000\000\000\000\000\000\000\000\000\000\000\002d\004\014\002\169\000\235\002\161\000\000\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`\002a\001j\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\167\002\173\002\133\000\000\000\000\001i\001j\001\132\000\000\000\000\002\138\000\000\002d\000\000\002\169\000\235\001\133\000\000\001\142\001q\004\018\000\000\000\000\002\161\000\000\001k\001z\003\137\001m\001n\000\000\000\000\000\000\000\000\002\170\000\000\000\000\002\167\000\000\001i\001j\000\000\000\000\002\191\002\173\001\142\002\172\000\000\004>\002d\000\000\002\169\000\235\000\000\000\000\000\000\000\000\000\000\000\000\001k\001z\000\000\001m\001n\000\000\000\000\000\000\002\193\000\000\001{\003\137\001|\002/\000\000\000\000\000\000\000\000\002\170\000\000\000\000\000\000\002\173\004C\000\000\000\000\000\000\002\191\002\167\001\142\002\172\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002d\000\000\002\169\000\235\001{\001\130\001|\002/\003\137\000\000\000\000\002\193\000\000\000\000\000\000\002\170\000\000\001s\000\000\000\000\000\235\001i\001j\000\000\002\191\000\000\001\142\002\172\002Y\000\000\000\000\000\000\002\173\000\000\000\000\000\000\000\000\000\000\000\000\001\130\000\000\001k\001z\000\000\001m\001n\001i\001j\002\193\000\000\000\000\001s\000\000\000\000\000\235\000\000\000\000\000\000\003\137\000\000\000\000\000\000\002Y\000\000\004J\002\170\001k\001z\000\000\001m\001n\000\000\000\000\000\000\002\191\000\000\001\142\002\172\000\000\000\000\001i\001j\001\132\000\000\000\000\001{\000\000\001|\002/\004S\000\000\001\133\000\000\001\142\001q\000\000\000\000\000\000\002\193\000\000\001k\001z\000\000\001m\001n\000\000\000\000\000\000\000\000\000\000\001{\000\000\001|\002/\000\000\000\000\001\132\000\000\003F\001j\001\130\000\000\000\000\004]\000\000\001\133\000\000\001\142\001q\000\000\000\000\000\000\001s\000\000\000\000\000\235\000\000\000\000\003b\001z\000\000\001m\001n\002Y\001{\001\130\001|\002/\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001s\000\000\000\000\000\235\002`\002a\001j\000\000\000\000\000\000\000\000\002Y\000\000\000\000\000\000\000\000\000\000\000\000\001i\001j\000\000\000\000\001\130\000\000\003g\003s\003t\004W\000\000\000\000\002`\002a\001j\000\000\001s\000\000\000\000\000\235\001k\001z\001\132\001m\001n\000\000\000\000\002Y\000\000\000\000\000\000\001\133\000\000\001\142\001q\004O\000\000\000\000\000\000\000\000\000\000\000\000\001\130\004\187\000\000\000\000\000\000\001\132\000\000\000\000\000\000\001i\001j\000\000\001s\000\000\001\133\000\235\001\142\001q\000\000\000\000\000\000\000\000\001{\000\000\001|\002/\000\000\000\000\000\000\001k\001z\000\000\001m\001n\000\000\000\000\000\000\000\000\000\000\001\132\001i\001j\000\000\000\000\002c\003w\004\177\000\000\001\133\000\000\001\142\001q\004\207\000\000\000\000\000\000\002d\001\130\002\169\000\235\001k\001z\000\000\001m\001n\001\026\000\000\000\000\001\027\001s\002c\000\000\000\235\001{\000\000\001|\002/\001\132\000\000\000\000\002Y\000\000\002d\004\211\002\169\000\235\001\133\001\026\001\142\001q\001\027\000\000\001\029\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\026\000\000\001{\000\000\001|\002/\001\130\000\000\000\000\000\000\000\000\000\000\001\029\000\000\000\000\000\000\005\029\000\000\001s\002\170\000\000\000\235\005\026\000\000\000\000\000\000\000\000\000\000\002\171\002Y\001\142\002\172\001\132\000\000\000\000\000\000\001#\001\130\005\147\000\000\000\000\001\133\000\000\001\142\001q\002\170\000\000\000\000\000\000\001s\000\000\001\031\000\235\000\000\002\171\000\000\001\142\002\172\001#\000\000\002Y\001i\001j\000\000\000\000\000\000\000\000\000\000\001 \000\000\000\000\000\000\000\000\001\031\001\018\001&\000\000\000\000\006~\000\000\000\000\001k\002E\001\132\001m\001n\000\000\000\000\000\000\000\000\001 \000\000\001\133\000\000\001\142\001q\001\018\001&\000\000\000\000\000\000\000\000\000\000\001\026\000\000\000\000\001\027\000\000\000\000\002F\000\000\000\000\001\026\000\000\001\132\001\027\000\000\000\000\000\000\000\000\000\000\0012\000\000\001\133\000\000\001\142\001q\000\000\000\000\001(\001\029\000\000\001)\000\000\000\000\001*\001+\005#\000\000\001\029\005\026\000\000\000\000\0012\000\000\000\000\000\000\000\000\000\000\005\026\000\000\001(\000\000\000\000\001)\000\000\006c\001*\001+\005#\001r\001,\000\000\000\000\0016\006q\000\000\000\000\001\026\000\000\000\000\001\027\001s\000\000\000\000\000\235\001#\000\000\000\000\000\000\000\000\000\000\000\000\001,\000\000\001#\0016\000\000\000\000\000\000\000\000\001\031\000\000\000\000\000\000\001\029\000\000\000\000\000\000\000\000\001\031\000\000\000\000\000\000\000\000\005\026\000\000\002G\001 \000\000\000\000\000\000\000\000\000\000\001\018\001&\000\000\001 \000\000\000\000\000\000\006{\000\000\001\018\001&\000\000\000\000\000\000\003[\003a\000\000\000\000\000\000\000\000\003F\001j\000\000\001\132\000\000\001i\001j\001#\000\000\000\000\003F\001j\001\141\000\000\001\142\001q\000\000\000\000\000\000\000\000\003b\001z\001\031\001m\001n\001k\001z\0012\001m\001n\003b\001z\000\000\001m\001n\001(\0012\000\000\001)\001 \000\000\001*\001+\005#\001(\001\018\001&\001)\007\t\000\000\001*\001+\005#\001\026\000\000\000\000\001\027\000\000\000\000\000\000\000\000\000\000\000\000\003g\003s\003t\000\000\001,\000\000\001{\0016\001|\002/\003g\003s\003t\001,\000\000\000\000\0016\001\029\000\000\007<\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0012\000\000\000\000\000\000\000\000\000\000\000\000\001\130\001(\000\000\000\000\001)\001\130\000\000\001*\001+\005#\001\130\000\000\001s\000\000\000\000\000\235\000\000\001s\000\000\000\000\000\235\000\000\001s\000\000\000\000\000\235\000\000\001#\002Y\000\000\000\000\001\026\000\000\001,\001\027\000\000\0016\000\000\000\000\000\000\000\000\000\000\001\031\000\000\000\000\003w\006\140\000\000\000\000\001i\001j\000\000\000\000\000\000\000\000\003w\006\174\000\000\001\029\001 \000\000\002`\002a\001j\000\000\001\018\001&\000\000\004\139\001k\001z\000\000\001m\001n\000\000\000\000\002\133\001\132\000\000\000\000\000\000\000\000\001\132\007-\002\138\000\000\001\133\001\132\001\142\001q\000\000\001\133\000\000\001\142\001q\000\000\001\133\002\161\001\142\001q\000\000\000\000\000\000\000\000\001#\000\000\000\000\000\000\000\000\002`\002a\001j\0012\001{\000\000\001|\001\146\000\000\000\000\001\031\001(\000\000\000\000\001)\002\133\000\000\001*\001+\007C\000\000\000\000\000\000\002\138\000\000\000\000\000\000\001 \000\000\000\000\000\000\000\000\000j\001\018\001&\000\000\002\161\000\000\000\000\001\130\000\000\000\000\000\000\001,\000\000\000\000\0016\000\000\000\000\000\000\000\000\001s\002\167\000\000\000\235\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002d\000\000\002\169\000\235\000\000\001i\001j\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0012\000\000\000\000\001i\001j\000\000\000\000\000\000\001(\001k\001z\001)\001m\001n\001*\001+\002\173\000\000\000\000\001\179\002\167\000\000\000\000\001k\001z\000\000\001m\001n\000\000\002`\002a\001j\002d\001\165\002\169\000\235\001\132\000\000\000\000\000\000\001,\000\000\004\222\004\146\002\133\001\133\000\000\001\142\001q\002\170\000\000\000\000\002\138\001{\000\000\001|\001\167\000\000\002\191\000\000\001\142\002\172\000\000\000\000\002\173\002\161\000\000\001{\000\000\001|\001\167\001i\001j\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\193\000\000\000\000\000\000\000\000\000\000\001\130\000\000\004\188\001k\001z\000\000\001m\001n\000\000\002\170\000\000\000\000\001s\001\169\001\130\000\235\000\000\000\000\002\191\000\000\001\142\002\172\002`\002a\001j\000\000\001s\000\000\000\000\000\235\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\133\002`\002a\001j\002\167\002\193\001i\001j\002\138\000\000\001{\000\000\001|\001\167\000\000\000\000\002d\000\000\002\169\000\235\000\000\002\161\000\000\000\000\003\241\000\000\001k\001z\000\000\001m\001n\000\000\002`\002a\001j\000\000\000\000\000\000\000\000\000\000\001\132\000\000\000\000\000\000\000\000\001\130\000\000\002\133\002\173\001\133\000\000\001\142\001q\000\000\001\132\002\138\000\000\001s\000\000\000\000\000\235\000\000\000\000\001\133\000\000\001\142\001q\000\000\002\161\000\000\001{\000\000\001|\002/\004^\000\000\000\000\000\000\000\000\000\000\000\000\002\170\000\000\000\000\000\000\002\167\001i\001j\000\000\000\000\002\191\000\000\001\142\002\172\000\000\000\000\000\000\002d\000\000\002\169\000\235\002c\000\000\000\000\000\000\001\130\001k\001z\000\000\001m\001n\000\000\000\000\002d\002\193\002\169\000\235\001s\000\000\000\000\000\235\000\000\001\132\000\000\000\000\000\000\000\000\000\000\0047\002\173\000\000\001\133\002\167\001\142\001q\000\000\000\000\001i\001j\000\000\000\000\002`\002a\001j\002d\000\000\002\169\000\235\000\000\003\243\001{\000\000\001|\0027\000\000\004U\002\133\001k\001z\000\000\001m\001n\002\170\000\000\002\138\000\000\000\000\000\000\000\000\000\000\000\000\002\191\000\000\001\142\002\172\000\000\002\173\002\161\002\170\000\000\000\000\000\000\001\132\000\000\000\000\001\130\000\000\002\171\000\000\001\142\002\172\001\133\000\000\001\142\001q\002\193\000\000\001s\006\219\000\000\000\235\001{\004/\001|\002/\000\000\000\000\000\000\000\000\002\170\000\000\000\000\000\000\000\000\000\000\000\000\007\193\000\000\002\191\006\222\001\142\002\172\000\000\000\000\000\000\000\000\000\000\002:\006\223\000\000\000\000\002`\002a\001j\000\000\000\000\001\130\000\000\000\000\000\000\000\000\002\167\002\193\000\000\000\000\000\000\002\133\000\000\001s\000\000\000\000\000\235\000\000\002d\002\138\002\169\000\235\000\000\006\224\002X\000\000\000\000\001\132\000\000\000\000\000\000\000\000\002\161\002`\002a\001j\001\133\000\000\001\142\001q\000\000\000\000\000\000\002`\002a\001j\000\000\000\000\002\133\000\000\002\173\000\000\000\000\000\000\000\000\000\000\002\138\000\000\002\133\000\000\006\225\000\000\000\000\000\000\000\000\000\000\002\138\000\000\000\000\002\161\006\226\000\000\000\000\000\000\000\000\000\000\003\245\000\000\001\132\002\161\000\000\000\000\000\000\002\170\000\000\000\000\000\000\001\133\000\000\001\142\001q\007\194\002\191\000\000\001\142\002\172\002\167\000\000\000\000\000\000\002`\002a\001j\000\000\000\000\000\000\000\000\000\000\002d\006\228\002\169\000\235\000\000\000\000\000\000\002\133\002\193\000\000\000\000\006\229\000\000\000\000\000\000\002\138\006\231\000\000\000\000\002`\002a\001j\000\000\000\000\000\000\002\167\000\000\000\000\002\161\000\000\006\233\000\000\002\173\000\000\002\133\002\167\000\000\002d\000\000\002\169\000\235\000\000\002\138\000\000\002`\002a\001j\002d\006\234\002\169\000\235\000\000\000\000\000\000\000\000\002\161\000\000\000\000\003}\002\133\000\000\000\000\000\000\000\000\000\000\002\170\000\000\002\138\000\000\002\173\000\000\000\000\000\000\000\000\002\191\000\000\001\142\002\172\000\000\002\173\002\161\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\167\000\000\000\000\002\183\000\000\000\000\002\193\000\000\000\000\000\000\002\170\000\000\002d\002\189\002\169\000\235\000\000\000\000\000\000\002\191\002\170\001\142\002\172\000\000\000\000\000\000\000\000\002\167\000\000\002\191\000\000\001\142\002\172\002`\002a\001j\000\000\000\000\000\000\002d\000\000\002\169\000\235\002\193\002\173\000\000\000\000\000\000\002\133\000\000\000\000\000\000\002\167\002\193\000\000\000\000\002\138\000\000\002`\002a\001j\000\000\000\000\000\000\002d\000\000\002\169\000\235\000\000\002\161\002\198\002\173\000\000\002\133\000\000\000\000\000\000\002\170\000\000\000\000\000\000\002\138\000\000\002`\002a\001j\002\191\000\000\001\142\002\172\000\000\000\000\000\000\000\000\002\161\000\000\002\173\002\209\002\133\000\000\001i\001j\000\000\000\000\002\170\000\000\002\138\000\000\000\000\000\000\002\193\000\000\000\000\002\191\000\000\001\142\002\172\000\000\000\000\002\161\001k\001l\002\215\001m\001n\000\000\000\000\000\000\000\000\002\170\000\000\000\000\000\000\002\167\000\000\000\000\000\000\002\193\002\191\000\000\001\142\002\172\002`\002a\001j\002d\000\000\002\169\000\235\000\000\000\000\000\000\002`\002a\001j\000\000\000\000\002\133\002\167\000\000\000\000\000\000\002\193\000\000\000\000\002\138\000\000\002\133\000\000\000\000\002d\000\000\002\169\000\235\000\000\002\138\000\000\002\173\002\161\000\000\000\000\000\000\000\000\002\167\000\000\000\000\000\000\000\000\002\161\002`\002a\001j\000\000\000\000\000\000\002d\000\000\002\169\000\235\001r\000\000\000\000\002\173\002\221\002\133\000\000\000\000\000\000\000\000\000\000\002\170\001s\002\138\000\000\000\235\000\000\000\000\000\000\000\000\002\191\000\000\001\142\002\172\000\000\000\000\002\161\000\000\002\173\002\227\000\000\000\000\000\000\000\000\000\000\000\000\002\170\000\000\000\000\000\000\000\000\000\000\000\000\002\167\002\193\002\191\000\000\001\142\002\172\000\000\000\000\000\000\000\000\002\167\002\233\002d\000\000\002\169\000\235\000\000\000\000\002\170\000\000\000\000\000\000\002d\000\000\002\169\000\235\002\193\002\191\000\000\001\142\002\172\000\000\000\000\000\000\001\132\000\000\000\000\002`\002a\001j\000\000\000\000\000\000\001\141\002\173\001\142\001q\002\167\000\000\000\000\000\000\002\193\002\133\000\000\002\173\001i\001j\000\000\000\000\002d\002\138\002\169\000\235\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\239\000\000\000\000\002\161\000\000\001k\001\140\002\170\001m\001n\002\245\000\000\000\000\000\000\000\000\000\000\002\191\002\170\001\142\002\172\000\000\002\173\000\000\000\000\000\000\000\000\002\191\000\000\001\142\002\172\000\000\000\000\000\000\000\000\002`\002a\001j\000\000\000\000\000\000\002\193\000\000\000\000\000\000\000\000\000\000\000\000\002\251\000\000\002\133\002\193\000\000\000\000\000\000\002\170\000\000\000\000\002\138\000\000\000\000\000\000\000\000\000\000\002\191\000\000\001\142\002\172\002\167\000\000\000\000\002\161\002`\002a\001j\000\000\000\000\000\000\000\000\000\000\002d\000\000\002\169\000\235\000\000\001r\000\000\002\133\002\193\000\000\000\000\000\000\002`\002a\001j\002\138\000\000\001s\000\000\000\000\000\235\000\000\000\000\001i\001j\000\000\000\000\002\133\002\161\000\000\000\000\000\000\002\173\000\000\000\000\002\138\001i\001j\000\000\002`\002a\001j\000\000\001k\001z\000\000\001m\001n\002\161\002`\002a\001j\000\000\000\000\002\133\002\167\001k\001z\003\001\001m\001n\000\000\002\138\000\000\002\133\002\170\000\000\002d\000\000\002\169\000\235\000\000\002\138\000\000\002\191\002\161\001\142\002\172\000\000\000\000\000\000\000\000\001\132\000\000\000\000\002\161\000\000\001{\000\000\001|\006\255\001\141\002\167\001\142\001q\000\000\000\000\000\000\002\193\002\173\001{\000\000\001|\007\171\002d\007\173\002\169\000\235\000\000\000\000\000\000\000\000\002\167\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\130\000\000\002d\003\007\002\169\000\235\000\000\000\000\000\000\000\000\002\170\000\000\001s\001\130\002\173\000\235\000\000\002\167\000\000\002\191\000\000\001\142\002\172\000\000\000\000\001s\000\000\002\167\000\235\002d\000\000\002\169\000\235\000\000\002\173\000\000\000\000\000\000\000\000\002d\003\r\002\169\000\235\002\193\000\000\000\000\000\000\002\170\000\000\002`\002a\001j\000\000\000\000\000\000\000\000\002\191\000\000\001\142\002\172\003\019\002\173\000\000\000\000\002\133\000\000\000\000\002\170\000\000\000\000\000\000\002\173\002\138\000\000\000\000\000\000\002\191\001\132\001\142\002\172\002\193\000\000\000\000\000\000\000\000\002\161\001\133\003\025\001\142\001q\001\132\000\000\000\000\000\000\002\170\000\000\000\000\003\031\000\000\001\133\002\193\001\142\001q\002\191\002\170\001\142\002\172\000\000\002`\002a\001j\000\000\000\000\002\191\000\000\001\142\002\172\000\000\002`\002a\001j\000\000\000\000\002\133\000\000\000\000\000\000\002\193\002`\002a\001j\002\138\000\000\002\133\000\000\000\000\000\000\002\193\000\000\000\000\000\000\002\138\000\000\000\000\002\161\000\000\000\000\000\000\000\000\002\167\000\000\002b\000\000\000\000\002\161\002`\002a\001j\000\000\000\000\000\000\002d\000\000\002\169\000\235\002`\002a\001j\000\000\000\000\002\133\000\000\000\000\000\000\000\000\002`\002a\001j\002\138\000\000\002\133\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\138\000\000\002\133\002\161\000\000\002\173\000\000\000\000\000\000\000\000\002\138\000\000\000\000\002\161\000\000\000\000\000\000\000\000\000\000\000\000\002\167\000\000\000\000\002\161\000\000\000\000\000\000\000\000\000\000\000\000\002\167\003%\002d\000\000\002\169\000\235\000\000\000\000\002\170\000\000\002c\000\000\002d\000\000\002\169\000\235\000\000\002\191\000\000\001\142\002\172\000\000\002d\000\000\002\169\000\235\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\173\000\000\000\000\002\167\000\000\000\000\000\000\002\193\000\000\000\000\002\173\000\000\000\000\002\167\000\000\002d\000\000\002\169\000\235\000\000\000\000\000\000\000\000\002\167\000\000\002d\003+\002\169\000\235\000\000\000\000\001\026\000\000\002\170\001\027\002d\0031\002\169\000\235\000\000\000\000\000\000\002\191\002\170\001\142\002\172\000\000\002\173\002`\002a\001j\000\000\002\191\002\170\001\142\002\172\000\000\002\173\001\029\000\000\000\000\000\000\002\171\002\133\001\142\002\172\002\193\002\173\003P\000\000\000\000\002\138\000\000\0037\000\000\000\000\002\193\000\000\000\000\000\000\002\170\000\000\000\000\003=\002\161\000\000\000\000\000\000\000\000\002\191\002\170\001\142\002\172\003C\000\000\002`\002a\001j\000\000\002\191\002\170\001\142\002\172\000\000\001#\000\000\000\000\000\000\000\000\002\191\002\133\001\142\002\172\002\193\000\000\000\000\000\000\000\000\002\138\001\031\000\000\000\000\000\000\002\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\161\000\000\002\193\000\000\000\000\001 \000\000\002`\002a\001j\000\000\001\018\001&\000\000\000\000\000\000\000\000\002\167\000\000\000\000\000\000\000\000\002\133\000\000\002`\002a\001j\000\000\000\000\002d\002\138\002\169\000\235\000\000\000\000\000\000\000\000\000\000\000\000\002\133\000\000\000\000\000\000\002\161\002`\002a\001j\002\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0012\002\133\002\161\002\173\000\000\000\000\002\167\000\000\001(\002\138\000\000\001)\000\000\000\000\001*\001+\002\145\000\000\002d\000\000\002\169\000\235\002\161\000\000\000\000\000\000\000\000\000\000\000\000\003\158\000\000\000\000\000\000\000\000\001i\001j\002\170\000\000\000\000\000\000\001,\000\000\000\000\0016\000\000\002\191\000\000\001\142\002\172\002\167\002\173\000\000\000\000\000\000\001k\002D\000\000\001m\001n\000\000\000\000\002d\000\000\002\169\000\235\000\000\002\167\000\000\000\000\002\193\000\000\000\000\000\000\002`\002a\001j\003\167\000\000\002d\000\000\002\169\000\235\000\000\002\170\000\000\000\000\002\167\000\000\002\133\000\000\000\000\000\000\002\191\002\173\001\142\002\172\002\138\000\000\002d\000\000\002\169\000\235\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\161\002\173\000\000\000\000\000\000\000\000\000\000\002\193\000\000\000\000\003\176\000\000\000\000\000\000\000\000\000\000\000\000\002\170\000\000\000\000\000\000\002\173\000\000\000\000\001r\000\000\002\191\003\186\001\142\002\172\000\000\000\000\000\000\000\000\002\170\000\000\001s\000\000\000\000\000\235\000\000\000\000\000\000\002\191\000\000\001\142\002\172\003\195\000\000\000\000\002\193\000\000\000\000\000\000\002\170\000\000\000\000\002`\002a\001j\000\000\000\000\000\000\002\191\002\167\001\142\002\172\002\193\000\000\000\000\000\000\000\000\002\133\000\000\000\000\000\000\002d\000\000\002\169\000\235\002\138\000\000\002`\002a\001j\000\000\000\000\002\193\002`\002a\001j\000\000\000\000\002\161\000\000\000\000\000\000\002\133\000\000\000\000\000\000\001\132\000\000\002\133\000\000\002\138\000\000\000\000\002\173\000\000\001\141\002\138\001\142\001q\000\000\000\000\000\000\000\000\002\161\000\000\000\000\000\000\000\000\000\000\002\161\002`\002a\001j\000\000\000\000\000\000\000\000\000\000\000\000\003\204\000\000\000\000\000\000\000\000\000\000\002\133\002\170\001\181\001j\000\000\000\000\000\000\000\000\002\138\000\000\002\191\000\000\001\142\002\172\000\000\000\000\000\000\002\167\000\000\000\000\000\000\002\161\001k\002t\000\000\001m\001n\000\000\000\000\002d\000\000\002\169\000\235\000\000\002\193\002`\002a\001j\000\000\000\000\000\000\000\000\002\167\000\000\000\000\000\000\000\000\000\000\002\167\000\000\002\133\000\000\000\000\000\000\002d\000\000\002\169\000\235\002\138\000\000\002d\002\173\002\169\000\235\000\000\004\000\003s\003t\000\000\000\000\000\000\002\161\000\000\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\167\002\173\003\215\000\000\000\000\000\000\000\000\002\173\000\000\002\170\000\000\000\000\002d\000\000\002\169\000\235\001\130\000\000\002\191\000\000\001\142\002\172\000\000\000\000\000\000\000\000\000\000\003\224\001s\000\000\000\000\000\235\000\000\003\233\002\170\002`\002a\001j\000\000\000\000\002\170\000\000\002\193\002\191\002\173\001\142\002\172\000\000\000\000\002\191\002\167\001\142\002\172\000\000\000\000\000\000\000\000\004\007\002{\002`\002a\001j\002d\000\000\002\169\000\235\000\000\002\193\000\000\000\000\003\240\000\000\000\000\002\193\002\133\000\000\000\000\002\170\000\000\000\000\001\026\000\000\002\138\001\027\000\000\000\000\002\191\000\000\001\142\002\172\000\000\000\000\000\000\001\132\002\173\002\161\002`\002a\001j\000\000\000\000\000\000\001\133\000\000\001\142\001q\000\000\001\029\000\000\000\000\002\193\002\133\005\158\000\000\001\026\000\000\000\000\001\027\000\000\002\138\004E\000\000\000\000\000\000\000\000\000\000\000\000\002\170\000\000\000\000\000\000\000\000\002\161\000\000\000\000\002c\002\191\000\000\001\142\002\172\000\000\001\029\000\000\000\000\000\000\001\026\000\000\002d\001\027\002\169\000\235\004\139\000\000\001#\000\000\000\000\000\000\000\000\000\000\002\167\002\193\000\000\000\000\000\000\000\000\000\000\004\142\000\000\001\031\000\000\000\000\002d\001\029\002\169\000\235\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \001\026\001#\000\000\001\027\000\000\001\018\001&\000\000\000\000\000\000\002\167\000\000\000\000\000\000\000\000\000\000\001\031\002\173\000\000\000\000\000\000\000\000\002d\000\000\002\169\000\235\002\170\001\029\000\000\000\000\000\000\000\000\001#\001 \000\000\002\171\000\000\001\142\002\172\001\018\001&\000\000\001\026\004D\000\000\001\027\000\000\001\031\000\000\000\000\002\170\000\000\0012\000\000\002\173\000\000\000\000\000\000\000\000\002\191\001(\001\142\002\172\001)\001 \000\000\001*\001+\005\163\001\029\001\018\001&\000\000\001#\006\148\001\026\000\000\000\000\001\027\000\000\004K\000\000\000\000\002\193\000\000\000\000\0012\002\170\001\031\000\000\000\000\000\000\001,\000\000\001(\0016\002\191\001)\001\142\002\172\001*\001+\001\029\000\000\000\000\001 \000\000\000\000\000\000\000\000\000\000\001\018\001&\000\000\000\000\001#\001\026\0012\000\000\001\027\002\193\000\000\000\000\000\000\000\000\001(\001,\000\000\001)\004\146\001\031\001*\001+\005\176\001\026\000\000\005\179\001\027\000\000\000\000\000\000\000\000\000\000\001\029\007\143\000\000\000\000\001 \001#\000\000\000\000\000\000\000\000\001\018\001&\000\000\000\000\001,\0012\000\000\0016\001\029\000\000\001\031\000\000\000\000\001(\000\000\000\000\001)\000\000\000\000\001*\001+\005\176\000\000\000\000\006\192\000\000\000\000\001 \000\000\001\026\000\000\000\000\001\027\001\018\001&\000\000\001#\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001,\000\000\0012\0016\000\000\000\000\001\031\000\000\000\000\001#\001(\001\029\000\000\001)\000\000\000\000\001*\001+\005\163\001G\000\000\000\000\000\000\001 \001\031\000\000\000\000\000\000\000\000\001\018\001&\000\000\000\000\000\000\001\026\0012\000\000\005\215\000\000\000\000\000\000\001 \001,\001(\000\000\0016\001)\001\018\001&\001*\001+\007\144\000\000\000\000\000\000\000\000\000\000\001#\000\000\001i\001j\001\029\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\031\000\000\000\000\001,\0012\000\000\0016\001k\001z\000\000\001m\001n\001(\000\000\000\000\001)\000\000\001 \001*\001+\001]\000\000\0012\001\018\001&\001i\001j\000\000\000\000\000\000\001(\000\000\000\000\001)\000\000\000\000\001*\001+\0013\000\000\000\000\000\000\000\000\000\000\001,\001k\001z\0016\001m\001n\001\031\001{\000\000\001|\001\171\000\000\001i\001j\000\000\000\000\000\000\000\000\001,\000\000\000\000\0016\000\000\001 \000\000\000\000\0012\000\000\000\000\001\018\001&\000\000\001k\001z\001(\001m\001n\001)\001i\001j\001*\001+\001\130\000\000\000\000\001{\000\000\001|\001\161\000\000\000\000\001i\001j\000\000\001s\000\000\000\000\000\235\001k\001z\000\000\001m\001n\000\000\000\000\000\000\001,\000\000\000\000\001K\000\000\001k\001z\000\000\001m\001n\001{\000\000\001|\001\158\001\130\000\000\000\000\000\000\001(\000\000\000\000\001)\000\000\000\000\001*\001+\001s\000\000\000\000\000\235\000\000\000\000\000\000\000\000\000\000\000\000\001{\000\000\001|\001~\000\000\000\000\000\000\000\000\000\000\001\130\000\000\000\000\000\000\001{\001,\001|\001\128\001\132\001i\001j\000\000\001s\000\000\000\000\000\235\000\000\001\133\000\000\001\142\001q\000\000\000\000\000\000\000\000\000\000\001\130\000\000\000\000\001k\001z\000\000\001m\001n\000\000\000\000\000\000\000\000\001s\001\130\000\000\000\235\000\000\001i\001j\000\000\001\132\000\000\000\000\000\000\000\000\001s\000\000\000\000\000\235\001\133\000\000\001\142\001q\000\000\000\000\000\000\000\000\001k\001z\000\000\001m\001n\000\000\000\000\001i\001j\000\000\001{\000\000\001|\001\131\001\132\001\026\000\000\000\000\001\027\000\000\000\000\000\000\000\000\001\133\000\000\001\142\001q\001k\001z\000\000\001m\001n\002`\002a\001j\000\000\000\000\000\000\000\000\000\000\001\132\000\000\001\029\000\000\001{\001\130\001|\001\157\000\000\001\133\000\000\001\142\001q\001\132\000\000\002}\000\000\001s\000\000\000\000\000\235\000\000\001\133\000\000\001\142\001q\001\026\000\000\000\000\001\027\000\000\001{\000\000\001|\001\149\000\000\000\000\000\000\000\000\001\130\000\000\000\000\000\000\000\000\000\000\000\000\001\026\000\000\001#\001\027\000\000\001s\000\000\001\029\000\235\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\031\000\000\000\000\001\130\000\000\000\000\000\000\000\000\000\000\000\000\001\029\000\000\000\000\000\000\000\000\001s\000\000\001 \000\235\001\132\000\000\000\000\000\000\001\018\001&\000\000\000\000\000\000\001\133\002c\001\142\001q\000\000\000\000\001i\001j\001#\000\000\000\000\001\026\000\000\002d\001\027\002\169\000\235\000\000\000\000\000\000\000\000\000\000\000\000\001\031\000\000\001\132\001k\001z\001#\001m\001n\000\000\000\000\000\000\001\133\000\000\001\142\001q\001\029\000\000\001 \000\000\0012\001\031\000\000\000\000\001\018\001&\000\000\000\000\001(\000\000\001\132\001)\000\000\000\000\001*\001+\001\151\001\026\001 \001\133\001\027\001\142\001q\000\000\001\018\001&\000\000\000\000\001{\000\000\001|\001\154\000\000\000\000\000\000\000\000\002\170\000\000\000\000\000\000\001,\000\000\001#\0016\001\029\002\171\000\000\001\142\002\172\001i\001j\0012\000\000\000\000\000\000\000\000\000\000\001\031\000\000\001(\000\000\000\000\001)\001\130\000\000\001*\001+\001\186\000\000\001k\001z\0012\001m\001n\001 \001s\000\000\000\000\000\235\001(\001\018\001&\001)\000\000\000\000\001*\001+\001\228\000\000\000\000\001#\001,\001\026\000\000\0016\001\027\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\031\000\000\000\000\000\000\000\000\000\000\001,\000\000\001{\0016\001|\002]\000\000\000\000\001\029\000\000\000\000\001 \000\000\000\000\000\000\000\000\0012\001\018\001&\000\000\000\000\000\000\000\000\001\026\001(\000\000\001\027\001)\000\000\001\132\001*\001+\001\230\001\026\000\000\000\000\001\027\001\130\001\133\000\000\001\142\001q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001s\001\029\000\000\000\235\000\000\001#\000\000\001,\000\000\000\000\0016\001\029\000\000\000\000\000\000\0012\000\000\000\000\000\000\000\000\001\031\000\000\000\000\001(\000\000\000\000\001)\000\000\000\000\001*\001+\0029\000\000\000\000\000\000\000\000\000\000\001 \000\000\000\000\000\000\000\000\000\000\001\018\001&\000\000\000\000\001#\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001,\001\026\001#\0016\001\027\000\000\000\000\001\031\000\000\000\000\001\132\001\026\000\000\000\000\001\027\000\000\000\000\001\031\000\000\001\133\000\000\001\142\001q\000\000\001 \000\000\000\000\000\000\001\029\000\000\001\018\001&\000\000\000\000\001 \0012\000\000\000\000\001\029\000\000\001\018\001&\000\000\001(\000\000\001\026\001)\000\000\001\027\001*\001+\002v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\029\000\000\001#\001,\000\000\0012\0016\000\000\000\000\000\000\000\000\000\000\001#\001(\000\000\0012\001)\001\031\000\000\001*\001+\002\143\000\000\001(\000\000\000\000\001)\001\031\000\000\001*\001+\002\147\000\000\000\000\001 \000\000\000\000\000\000\000\000\000\000\001\018\001&\000\000\000\000\001 \001,\001#\000\000\0016\000\000\001\018\001&\001i\001j\000\000\001,\000\000\000\000\0016\001i\001j\001\031\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001i\001j\000\000\001k\001z\000\000\001m\001n\000\000\001 \001k\001z\000\000\001m\001n\001\018\001&\000\000\0012\000\000\001k\001z\000\000\001m\001n\000\000\001(\000\000\0012\001)\000\000\000\000\001*\001+\003M\000\000\001(\000\000\000\000\001)\000\000\000\000\001*\001+\003T\000\000\000\000\001{\000\000\001|\003k\000\000\000\000\000\000\001{\000\000\001|\003m\001,\000\000\000\000\0016\0012\000\000\001{\000\000\001|\003o\001,\000\000\001(\0016\000\000\001)\000\000\000\000\001*\001+\003d\000\000\000\000\000\000\001\130\002`\002a\001j\000\000\000\000\000\000\001\130\000\000\000\000\000\000\000\000\001s\000\000\000\000\000\235\000\000\001\130\000\000\001s\001,\006\219\000\235\0016\004\024\000\000\000\000\000\000\000\000\001s\000\000\004 \000\235\001i\001j\000\000\007\202\000\000\000\000\007\203\000\000\000\000\006\222\001i\001j\000\000\000\000\000\000\000\000\000\000\000\000\006\223\000\000\001k\001z\004!\001m\001n\000\000\000\000\000\000\000\000\000\000\001k\001z\000\000\001m\001n\000\000\002`\002a\001j\000\000\000\000\000\000\000\000\000\000\001\132\000\000\000\000\000\000\006\224\000\000\000\000\001\132\000\000\001\133\001\026\001\142\001q\001\027\000\000\002\154\001\133\001\132\001\142\001q\001{\000\000\001|\003v\002c\000\000\001\133\000\000\001\142\001q\001{\000\000\001|\005\011\000\000\000\000\004#\001\029\002\169\000\235\000\255\006\225\000\000\000\000\000\000\000\000\000\000\001\026\000\000\000\000\001\027\006\226\000\000\000\000\000\000\001\130\000\000\000\000\000\000\000\000\001\026\000\000\000\000\001\027\000\000\001\130\000\000\001s\000\000\000\000\000\235\007\208\000\000\004\027\001\029\000\000\000\000\001s\000\000\000\000\000\235\000\000\000\000\001#\000\000\000\000\000\000\001\029\000\000\000\000\006\228\000\000\002c\000\000\000\000\000\000\000\000\000\000\001\031\000\000\006\229\002\170\000\000\000\000\002d\006\231\002\169\000\235\000\000\000\000\002\171\000\000\001\142\002\172\000\000\001 \000\000\000\000\000\000\006\233\001#\001\018\001&\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\132\001#\000\000\001\031\000\000\006\234\000\000\000\000\000\000\001\133\001\132\001\142\001q\000\000\000\000\000\000\001\031\000\000\000\000\001\133\001 \001\142\001q\000\000\000\000\000\000\001\018\001&\000\000\000\000\000\000\001\026\000\000\001 \001\027\000\000\0012\002\170\000\000\001\018\001&\000\000\001\026\000\000\001(\005\212\002\171\001)\001\142\002\172\001*\001+\005\028\000\000\000\000\000\000\000\000\000\000\001\029\000\000\000\000\000\000\000\000\000\000\001\026\000\000\000\000\001\027\000\000\001\029\000\000\000\000\000\000\0012\000\000\000\000\001,\000\000\000\000\0016\000\000\001(\001\026\000\000\001)\005\212\0012\001*\001+\005|\000\000\001\029\000\000\000\000\001(\000\000\000\000\001)\000\000\000\000\001*\001+\005\136\000\000\001#\000\000\000\000\000\000\000\000\001\029\000\000\000\000\000\000\001,\000\000\005\214\0016\000\000\000\000\001\031\000\000\000\000\000\000\000\000\000\000\000\000\001,\000\000\000\000\0016\001\031\000\000\000\000\000\000\000\000\000\000\001 \001#\000\000\000\000\000\000\000\000\001\018\001&\000\000\000\000\000\000\001 \000\000\000\000\000\000\000\000\001\031\001\018\005\217\005\214\000\000\000\000\001\026\000\000\000\000\005\212\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \001\031\000\000\000\000\000\000\000\000\001\018\001&\000\000\000\000\001\026\000\000\000\000\005\212\000\000\000\000\001\029\000\000\001 \000\000\0012\000\000\000\000\000\000\001\018\005\217\000\000\000\000\001(\000\000\000\000\001)\000\000\000\000\001*\001+\005\162\001\029\000\000\001(\000\000\000\000\005\218\000\000\000\000\001*\001+\000\000\000\000\000\000\000\000\000\000\000\000\0012\000\000\005\165\000\000\005\222\000\000\005\220\001,\001(\005\214\0016\001)\000\000\000\000\001*\001+\005\178\000\000\001,\000\000\000\000\000\000\000\000\000\000\001\031\000\000\001(\000\000\000\000\005\218\005\214\000\000\001*\001+\000\000\000\000\000\000\000\000\000\000\000\000\001,\001 \005\165\0016\005\221\001\031\005\220\001\018\005\217\000\000\000\000\000\000\001\026\000\000\000\000\001\027\000\000\000\000\001,\000\000\000\000\000\000\001 \000\000\001\026\000\000\000\000\001\027\001\018\005\217\000\000\000\000\000\000\001\026\000\000\000\000\001\027\000\000\000\000\001\029\000\000\000\000\000\000\000\000\000\000\000\000\001\026\000\000\000\000\005\212\000\000\001\029\000\000\000\000\001\026\000\000\000\000\005\212\000\000\000\000\001\029\000\000\001(\000\000\000\000\005\218\000\000\000\000\001*\001+\000\000\000\000\000\000\001\029\000\000\000\000\000\000\000\000\005\165\000\000\005\219\001\029\005\220\001(\000\000\001#\005\218\000\000\000\000\001*\001+\000\000\000\000\000\000\001,\000\000\000\000\001#\000\000\005\165\001\031\005\231\000\000\005\220\000\000\000\000\001#\000\000\000\000\000\000\000\000\000\000\001\031\000\000\000\000\001,\000\000\001 \000\000\005\214\000\000\001\031\000\000\001\018\001&\000\000\000\000\005\214\000\000\001 \000\000\000\000\000\000\000\000\001\031\001\018\001&\000\000\001 \000\000\000\000\000\000\001\031\000\000\001\018\001&\000\000\000\000\000\000\000\000\000\000\001 \000\000\000\000\000\000\000\000\000\000\001\018\005\217\001 \001\026\000\000\000\000\001\027\000\000\001\018\005\217\000\000\000\000\000\000\0012\000\000\000\000\001\026\000\000\000\000\001\027\000\000\001(\000\000\000\000\001)\0012\000\000\001*\001+\006N\001\029\000\000\000\000\001(\0012\000\000\001)\000\000\000\000\001*\001+\006`\001(\001\029\000\000\001)\000\000\000\000\001*\001+\006x\000\000\000\000\001,\000\000\001(\0016\000\000\005\218\000\000\000\000\001*\001+\001(\000\000\001,\005\218\000\000\0016\001*\001+\005\165\000\000\006\179\001,\005\220\001#\0016\000\000\005\165\000\000\006\203\001\026\005\220\000\000\001\027\000\000\001,\000\000\001#\000\000\001\031\000\000\000\000\000\000\001,\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\031\000\000\000\000\000\000\001 \001\029\000\000\000\000\000\000\000\000\001\018\001&\000\000\000\000\000\000\001\026\000\000\001 \001\027\000\000\000\000\000\000\000\000\001\018\001&\000\000\000\000\000\000\001\026\000\000\000\000\001\027\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\029\000\000\000\000\000\000\000\000\000\000\000\000\001\026\000\000\001#\001\027\000\000\000\000\001\029\000\000\0012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001(\001\031\000\000\001)\000\000\0012\001*\001+\007\002\000\000\000\000\001\029\000\000\001(\000\000\000\000\001)\000\000\001 \001*\001+\007B\000\000\001#\001\018\001&\002`\002a\001j\000\000\000\000\000\000\001,\000\000\000\000\0016\001#\000\000\001\031\000\000\000\000\000\000\000\000\000\000\000\000\001,\000\000\000\000\0016\003\241\000\000\001\031\000\000\000\000\000\000\001 \000\000\001#\000\000\000\000\000\000\001\018\001&\000\000\001\026\000\000\000\000\001\027\001 \000\000\000\000\0012\001\031\006\159\001\018\001&\000\000\000\000\000\000\001(\000\000\000\000\001)\006\219\000\000\001*\001+\007E\000\000\001 \000\000\001\029\002`\002a\001j\001\018\001&\000\000\007\202\000\000\000\000\007\203\000\000\000\000\006\222\002`\002a\001j\0012\000\000\000\000\001,\000\000\006\223\0016\002\168\001(\000\000\000\000\001)\000\000\0012\001*\001+\000\000\000\000\002c\000\000\002\192\001(\000\000\000\000\001)\000\000\000\000\001*\001+\001#\002d\000\000\002\169\000\235\0012\006\224\000\000\002`\002a\001j\001,\000\000\001(\001I\001\031\001)\000\000\000\000\001*\001+\000\000\000\000\000\000\001,\000\000\000\000\001\223\000\000\000\000\000\000\003\148\001 \000\000\000\000\000\000\000\000\003\244\001\018\001&\000\000\000\000\000\000\006\225\000\000\001,\000\000\000\000\001\225\000\000\000\000\000\000\000\000\006\226\000\000\002c\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\170\002d\002c\002\169\000\235\000\000\000\000\007\213\000\000\002\171\000\000\001\142\002\172\000\000\002d\000\000\002\169\000\235\000\000\0012\000\000\000\000\000\000\000\000\000\000\000\000\006\228\001(\000\000\000\000\001)\000\000\000\000\001*\001+\000\000\006\229\000\000\000\000\000\000\000\000\006\231\002c\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002d\006\233\002\169\000\235\000\000\001,\000\000\000\000\004\141\000\000\000\000\000\000\002\170\000\000\000\000\000\000\000\000\000\000\000\000\006\234\000\000\002\171\000\000\001\142\002\172\002\170\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\171\000\000\001\142\002\172\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\170\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\171\000\000\001\142\002\172")) and semantic_action = [| @@ -1473,9 +1488,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3941 "src/ocaml/preprocess/parser_raw.mly" +# 4137 "src/ocaml/preprocess/parser_raw.mly" ( "+" ) -# 1479 "src/ocaml/preprocess/parser_raw.ml" +# 1494 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1498,9 +1513,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3942 "src/ocaml/preprocess/parser_raw.mly" +# 4138 "src/ocaml/preprocess/parser_raw.mly" ( "+." ) -# 1504 "src/ocaml/preprocess/parser_raw.ml" +# 1519 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1523,9 +1538,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.core_type) = -# 3490 "src/ocaml/preprocess/parser_raw.mly" +# 3630 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 1529 "src/ocaml/preprocess/parser_raw.ml" +# 1544 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1538,14 +1553,14 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = tyvar; - MenhirLib.EngineTypes.startp = _startpos_tyvar_; - MenhirLib.EngineTypes.endp = _endpos_tyvar_; + MenhirLib.EngineTypes.semv = _2_inlined1; + MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _2; @@ -1561,33 +1576,46 @@ module Tables = struct }; }; } = _menhir_stack in - let tyvar : (string) = Obj.magic tyvar in - let _3 : unit = Obj.magic _3 in + let _2_inlined1 : (string) = Obj.magic _2_inlined1 in + let _1 : unit = Obj.magic _1 in let _2 : unit = Obj.magic _2 in let ty : (Parsetree.core_type) = Obj.magic ty in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_ty_ in - let _endpos = _endpos_tyvar_ in + let _endpos = _endpos__2_inlined1_ in let _v : (Parsetree.core_type) = let _1 = - let _1 = -# 3493 "src/ocaml/preprocess/parser_raw.mly" + let _1 = + let tyvar = + let (_endpos__2_, _2) = (_endpos__2_inlined1_, _2_inlined1) in + let _endpos = _endpos__2_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 3578 "src/ocaml/preprocess/parser_raw.mly" + ( mkrhs _2 _sloc ) +# 1597 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3633 "src/ocaml/preprocess/parser_raw.mly" ( Ptyp_alias(ty, tyvar) ) -# 1576 "src/ocaml/preprocess/parser_raw.ml" - in - let (_endpos__1_, _startpos__1_) = (_endpos_tyvar_, _startpos_ty_) in +# 1603 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos__2_inlined1_, _startpos_ty_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 1585 "src/ocaml/preprocess/parser_raw.ml" +# 1613 "src/ocaml/preprocess/parser_raw.ml" in -# 3495 "src/ocaml/preprocess/parser_raw.mly" +# 3635 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 1591 "src/ocaml/preprocess/parser_raw.ml" +# 1619 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1624,7 +1652,8 @@ module Tables = struct }; } = _menhir_stack in let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let body : (Parsetree.pattern * Parsetree.expression * bool) = Obj.magic body in + let body : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option * bool) = Obj.magic body in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -1633,30 +1662,30 @@ module Tables = struct let _v : (Ast_helper.let_binding) = let attrs2 = let _1 = _1_inlined2 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 1639 "src/ocaml/preprocess/parser_raw.ml" +# 1668 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined2_ in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 1648 "src/ocaml/preprocess/parser_raw.ml" +# 1677 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2734 "src/ocaml/preprocess/parser_raw.mly" +# 2842 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in mklb ~loc:_sloc false body attrs ) -# 1660 "src/ocaml/preprocess/parser_raw.ml" +# 1689 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1679,9 +1708,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3825 "src/ocaml/preprocess/parser_raw.mly" +# 4021 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 1685 "src/ocaml/preprocess/parser_raw.ml" +# 1714 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1704,188 +1733,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3826 "src/ocaml/preprocess/parser_raw.mly" +# 4022 "src/ocaml/preprocess/parser_raw.mly" ( Lident _1 ) -# 1710 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - } = _menhir_stack in - let _3 : unit = Obj.magic _3 in - let _2 : (Parsetree.core_type) = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__3_ in - let _v : (Parsetree.core_type) = -# 3551 "src/ocaml/preprocess/parser_raw.mly" - ( _2 ) -# 1749 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined3; - MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - }; - }; - } = _menhir_stack in - let _5 : unit = Obj.magic _5 in - let _1_inlined3 : (Parsetree.module_type) = Obj.magic _1_inlined3 in - let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in - let _2 : unit = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__5_ in - let _v : (Parsetree.core_type) = let _4 = - let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 3611 "src/ocaml/preprocess/parser_raw.mly" - ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in - let descr = Ptyp_package (lid, cstrs) in - mktyp ~loc:_sloc ~attrs descr ) -# 1816 "src/ocaml/preprocess/parser_raw.ml" - - in - let _3 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 1826 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 1832 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 3553 "src/ocaml/preprocess/parser_raw.mly" - ( wrap_typ_attrs ~loc:_sloc (reloc_typ ~loc:_sloc _4) _3 ) -# 1841 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - } = _menhir_stack in - let _2 : (string) = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__2_ in - let _v : (Parsetree.core_type) = let _1 = - let _1 = -# 3556 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_var _2 ) -# 1874 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos__1_ = _endpos__2_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1027 "src/ocaml/preprocess/parser_raw.mly" - ( mktyp ~loc:_sloc _1 ) -# 1883 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3588 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 1889 "src/ocaml/preprocess/parser_raw.ml" +# 1739 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1898,34 +1748,19 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = type_; + MenhirLib.EngineTypes.startp = _startpos_type__; + MenhirLib.EngineTypes.endp = _endpos_type__; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let _1 : unit = Obj.magic _1 in + let type_ : (Parsetree.core_type) = Obj.magic type_ in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__1_ in - let _v : (Parsetree.core_type) = let _1 = - let _1 = -# 3558 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_any ) -# 1915 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1027 "src/ocaml/preprocess/parser_raw.mly" - ( mktyp ~loc:_sloc _1 ) -# 1923 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3588 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 1929 "src/ocaml/preprocess/parser_raw.ml" + let _startpos = _startpos_type__ in + let _endpos = _endpos_type__ in + let _v : (Parsetree.core_type) = +# 3766 "src/ocaml/preprocess/parser_raw.mly" + ( type_ ) +# 1764 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -1954,35 +1789,35 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 1960 "src/ocaml/preprocess/parser_raw.ml" +# 1795 "src/ocaml/preprocess/parser_raw.ml" in let tys = -# 3603 "src/ocaml/preprocess/parser_raw.mly" +# 3799 "src/ocaml/preprocess/parser_raw.mly" ( [] ) -# 1966 "src/ocaml/preprocess/parser_raw.ml" +# 1801 "src/ocaml/preprocess/parser_raw.ml" in -# 3561 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_constr(tid, tys) ) -# 1971 "src/ocaml/preprocess/parser_raw.ml" +# 3770 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_constr (tid, tys) ) +# 1806 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 1980 "src/ocaml/preprocess/parser_raw.ml" +# 1815 "src/ocaml/preprocess/parser_raw.ml" in -# 3588 "src/ocaml/preprocess/parser_raw.mly" +# 3784 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 1986 "src/ocaml/preprocess/parser_raw.ml" +# 1821 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2018,20 +1853,20 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 2024 "src/ocaml/preprocess/parser_raw.ml" +# 1859 "src/ocaml/preprocess/parser_raw.ml" in let tys = -# 3605 "src/ocaml/preprocess/parser_raw.mly" - ( [ty] ) -# 2030 "src/ocaml/preprocess/parser_raw.ml" +# 3801 "src/ocaml/preprocess/parser_raw.mly" + ( [ ty ] ) +# 1865 "src/ocaml/preprocess/parser_raw.ml" in -# 3561 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_constr(tid, tys) ) -# 2035 "src/ocaml/preprocess/parser_raw.ml" +# 3770 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_constr (tid, tys) ) +# 1870 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__1_ = _startpos_ty_ in @@ -2039,15 +1874,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 2045 "src/ocaml/preprocess/parser_raw.ml" +# 1880 "src/ocaml/preprocess/parser_raw.ml" in -# 3588 "src/ocaml/preprocess/parser_raw.mly" +# 3784 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 2051 "src/ocaml/preprocess/parser_raw.ml" +# 1886 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2098,9 +1933,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 2104 "src/ocaml/preprocess/parser_raw.ml" +# 1939 "src/ocaml/preprocess/parser_raw.ml" in let tys = @@ -2108,24 +1943,24 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 2112 "src/ocaml/preprocess/parser_raw.ml" +# 1947 "src/ocaml/preprocess/parser_raw.ml" in -# 1152 "src/ocaml/preprocess/parser_raw.mly" +# 1210 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 2117 "src/ocaml/preprocess/parser_raw.ml" +# 1952 "src/ocaml/preprocess/parser_raw.ml" in -# 3607 "src/ocaml/preprocess/parser_raw.mly" +# 3803 "src/ocaml/preprocess/parser_raw.mly" ( tys ) -# 2123 "src/ocaml/preprocess/parser_raw.ml" +# 1958 "src/ocaml/preprocess/parser_raw.ml" in -# 3561 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_constr(tid, tys) ) -# 2129 "src/ocaml/preprocess/parser_raw.ml" +# 3770 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_constr (tid, tys) ) +# 1964 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -2133,118 +1968,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 2139 "src/ocaml/preprocess/parser_raw.ml" +# 1974 "src/ocaml/preprocess/parser_raw.ml" in -# 3588 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 2145 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - } = _menhir_stack in - let _3 : unit = Obj.magic _3 in - let _2 : (Parsetree.object_field list * Asttypes.closed_flag) = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__3_ in - let _v : (Parsetree.core_type) = let _1 = - let _1 = -# 3563 "src/ocaml/preprocess/parser_raw.mly" - ( let (f, c) = _2 in Ptyp_object (f, c) ) -# 2185 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos__1_ = _endpos__3_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1027 "src/ocaml/preprocess/parser_raw.mly" - ( mktyp ~loc:_sloc _1 ) -# 2194 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3588 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 2200 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - } = _menhir_stack in - let _2 : unit = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__2_ in - let _v : (Parsetree.core_type) = let _1 = - let _1 = -# 3565 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_object ([], Closed) ) -# 2233 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos__1_ = _endpos__2_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1027 "src/ocaml/preprocess/parser_raw.mly" - ( mktyp ~loc:_sloc _1 ) -# 2242 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3588 "src/ocaml/preprocess/parser_raw.mly" +# 3784 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 2248 "src/ocaml/preprocess/parser_raw.ml" +# 1980 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2280,20 +2012,20 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 2286 "src/ocaml/preprocess/parser_raw.ml" +# 2018 "src/ocaml/preprocess/parser_raw.ml" in let tys = -# 3603 "src/ocaml/preprocess/parser_raw.mly" +# 3799 "src/ocaml/preprocess/parser_raw.mly" ( [] ) -# 2292 "src/ocaml/preprocess/parser_raw.ml" +# 2024 "src/ocaml/preprocess/parser_raw.ml" in -# 3569 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_class(cid, tys) ) -# 2297 "src/ocaml/preprocess/parser_raw.ml" +# 3774 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_class (cid, tys) ) +# 2029 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__1_ = _startpos__2_ in @@ -2301,15 +2033,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 2307 "src/ocaml/preprocess/parser_raw.ml" +# 2039 "src/ocaml/preprocess/parser_raw.ml" in -# 3588 "src/ocaml/preprocess/parser_raw.mly" +# 3784 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 2313 "src/ocaml/preprocess/parser_raw.ml" +# 2045 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2352,20 +2084,20 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 2358 "src/ocaml/preprocess/parser_raw.ml" +# 2090 "src/ocaml/preprocess/parser_raw.ml" in let tys = -# 3605 "src/ocaml/preprocess/parser_raw.mly" - ( [ty] ) -# 2364 "src/ocaml/preprocess/parser_raw.ml" +# 3801 "src/ocaml/preprocess/parser_raw.mly" + ( [ ty ] ) +# 2096 "src/ocaml/preprocess/parser_raw.ml" in -# 3569 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_class(cid, tys) ) -# 2369 "src/ocaml/preprocess/parser_raw.ml" +# 3774 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_class (cid, tys) ) +# 2101 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__1_ = _startpos_ty_ in @@ -2373,15 +2105,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 2379 "src/ocaml/preprocess/parser_raw.ml" +# 2111 "src/ocaml/preprocess/parser_raw.ml" in -# 3588 "src/ocaml/preprocess/parser_raw.mly" +# 3784 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 2385 "src/ocaml/preprocess/parser_raw.ml" +# 2117 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2439,9 +2171,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 2445 "src/ocaml/preprocess/parser_raw.ml" +# 2177 "src/ocaml/preprocess/parser_raw.ml" in let tys = @@ -2449,24 +2181,24 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 2453 "src/ocaml/preprocess/parser_raw.ml" +# 2185 "src/ocaml/preprocess/parser_raw.ml" in -# 1152 "src/ocaml/preprocess/parser_raw.mly" +# 1210 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 2458 "src/ocaml/preprocess/parser_raw.ml" +# 2190 "src/ocaml/preprocess/parser_raw.ml" in -# 3607 "src/ocaml/preprocess/parser_raw.mly" +# 3803 "src/ocaml/preprocess/parser_raw.mly" ( tys ) -# 2464 "src/ocaml/preprocess/parser_raw.ml" +# 2196 "src/ocaml/preprocess/parser_raw.ml" in -# 3569 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_class(cid, tys) ) -# 2470 "src/ocaml/preprocess/parser_raw.ml" +# 3774 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_class (cid, tys) ) +# 2202 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -2474,15 +2206,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 2480 "src/ocaml/preprocess/parser_raw.ml" +# 2212 "src/ocaml/preprocess/parser_raw.ml" in -# 3588 "src/ocaml/preprocess/parser_raw.mly" +# 3784 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 2486 "src/ocaml/preprocess/parser_raw.ml" +# 2218 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2495,9 +2227,9 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = type_; + MenhirLib.EngineTypes.startp = _startpos_type__; + MenhirLib.EngineTypes.endp = _endpos_type__; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _2; @@ -2512,288 +2244,44 @@ module Tables = struct }; }; } = _menhir_stack in - let _3 : unit = Obj.magic _3 in - let _2 : (Parsetree.row_field) = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__3_ in - let _v : (Parsetree.core_type) = let _1 = - let _1 = -# 3572 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_variant([_2], Closed, None) ) -# 2526 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos__1_ = _endpos__3_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1027 "src/ocaml/preprocess/parser_raw.mly" - ( mktyp ~loc:_sloc _1 ) -# 2535 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3588 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 2541 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = xs; - MenhirLib.EngineTypes.startp = _startpos_xs_; - MenhirLib.EngineTypes.endp = _endpos_xs_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - } = _menhir_stack in - let _4 : unit = Obj.magic _4 in - let xs : (Parsetree.row_field list) = Obj.magic xs in + let type_ : (Parsetree.core_type) = Obj.magic type_ in let _2 : unit = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__4_ in - let _v : (Parsetree.core_type) = let _1 = - let _1 = - let _3 = - let _1 = - let xs = -# 253 "" - ( List.rev xs ) -# 2591 "src/ocaml/preprocess/parser_raw.ml" - in - -# 1124 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 2596 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3617 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 2602 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3574 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_variant(_3, Closed, None) ) -# 2608 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos__1_ = _endpos__4_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1027 "src/ocaml/preprocess/parser_raw.mly" - ( mktyp ~loc:_sloc _1 ) -# 2618 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3588 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 2624 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = xs; - MenhirLib.EngineTypes.startp = _startpos_xs_; - MenhirLib.EngineTypes.endp = _endpos_xs_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - }; - } = _menhir_stack in - let _5 : unit = Obj.magic _5 in - let xs : (Parsetree.row_field list) = Obj.magic xs in - let _3 : unit = Obj.magic _3 in - let _2 : (Parsetree.row_field) = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in + let _1 : (Longident.t) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__5_ in + let _endpos = _endpos_type__ in let _v : (Parsetree.core_type) = let _1 = let _1 = - let _4 = - let _1 = - let xs = -# 253 "" - ( List.rev xs ) -# 2681 "src/ocaml/preprocess/parser_raw.ml" - in - -# 1124 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 2686 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3617 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 2692 "src/ocaml/preprocess/parser_raw.ml" + let mod_ident = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in - in - -# 3576 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_variant(_2 :: _4, Closed, None) ) -# 2698 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos__1_ = _endpos__5_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - # 1027 "src/ocaml/preprocess/parser_raw.mly" - ( mktyp ~loc:_sloc _1 ) -# 2708 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3588 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 2714 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = xs; - MenhirLib.EngineTypes.startp = _startpos_xs_; - MenhirLib.EngineTypes.endp = _endpos_xs_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - } = _menhir_stack in - let _4 : unit = Obj.magic _4 in - let xs : (Parsetree.row_field list) = Obj.magic xs in - let _2 : (unit option) = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__4_ in - let _v : (Parsetree.core_type) = let _1 = - let _1 = - let _3 = - let _1 = - let xs = -# 253 "" - ( List.rev xs ) -# 2764 "src/ocaml/preprocess/parser_raw.ml" - in - -# 1124 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 2769 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3617 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 2775 "src/ocaml/preprocess/parser_raw.ml" + ( mkrhs _1 _sloc ) +# 2263 "src/ocaml/preprocess/parser_raw.ml" in -# 3578 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_variant(_3, Open, None) ) -# 2781 "src/ocaml/preprocess/parser_raw.ml" +# 3778 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_open (mod_ident, type_) ) +# 2269 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos__4_ in + let _endpos__1_ = _endpos_type__ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 2791 "src/ocaml/preprocess/parser_raw.ml" +# 2279 "src/ocaml/preprocess/parser_raw.ml" in -# 3588 "src/ocaml/preprocess/parser_raw.mly" +# 3784 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 2797 "src/ocaml/preprocess/parser_raw.ml" +# 2285 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -2806,9 +2294,9 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.semv = ident; + MenhirLib.EngineTypes.startp = _startpos_ident_; + MenhirLib.EngineTypes.endp = _endpos_ident_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _menhir_s; MenhirLib.EngineTypes.semv = _1; @@ -2817,231 +2305,31 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; }; } = _menhir_stack in - let _2 : unit = Obj.magic _2 in + let ident : (string) = Obj.magic ident in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__2_ in + let _endpos = _endpos_ident_ in let _v : (Parsetree.core_type) = let _1 = let _1 = -# 3580 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_variant([], Open, None) ) -# 2830 "src/ocaml/preprocess/parser_raw.ml" +# 3780 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_var ident ) +# 2318 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos__2_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1027 "src/ocaml/preprocess/parser_raw.mly" - ( mktyp ~loc:_sloc _1 ) -# 2839 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3588 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 2845 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = xs; - MenhirLib.EngineTypes.startp = _startpos_xs_; - MenhirLib.EngineTypes.endp = _endpos_xs_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - } = _menhir_stack in - let _4 : unit = Obj.magic _4 in - let xs : (Parsetree.row_field list) = Obj.magic xs in - let _2 : (unit option) = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__4_ in - let _v : (Parsetree.core_type) = let _1 = - let _1 = - let _3 = - let _1 = - let xs = -# 253 "" - ( List.rev xs ) -# 2895 "src/ocaml/preprocess/parser_raw.ml" - in - -# 1124 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 2900 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3617 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 2906 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3582 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_variant(_3, Closed, Some []) ) -# 2912 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos__1_ = _endpos__4_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1027 "src/ocaml/preprocess/parser_raw.mly" - ( mktyp ~loc:_sloc _1 ) -# 2922 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3588 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 2928 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _6; - MenhirLib.EngineTypes.startp = _startpos__6_; - MenhirLib.EngineTypes.endp = _endpos__6_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = xs_inlined1; - MenhirLib.EngineTypes.startp = _startpos_xs_inlined1_; - MenhirLib.EngineTypes.endp = _endpos_xs_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = xs; - MenhirLib.EngineTypes.startp = _startpos_xs_; - MenhirLib.EngineTypes.endp = _endpos_xs_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - }; - }; - } = _menhir_stack in - let _6 : unit = Obj.magic _6 in - let xs_inlined1 : (string list) = Obj.magic xs_inlined1 in - let _4 : unit = Obj.magic _4 in - let xs : (Parsetree.row_field list) = Obj.magic xs in - let _2 : (unit option) = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__6_ in - let _v : (Parsetree.core_type) = let _1 = - let _1 = - let _5 = - let xs = xs_inlined1 in - let _1 = - let xs = -# 253 "" - ( List.rev xs ) -# 2993 "src/ocaml/preprocess/parser_raw.ml" - in - -# 1092 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 2998 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3645 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 3004 "src/ocaml/preprocess/parser_raw.ml" - - in - let _3 = - let _1 = - let xs = -# 253 "" - ( List.rev xs ) -# 3012 "src/ocaml/preprocess/parser_raw.ml" - in - -# 1124 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 3017 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3617 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 3023 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3584 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_variant(_3, Closed, Some _5) ) -# 3029 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos__1_ = _endpos__6_ in + let _endpos__1_ = _endpos_ident_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 3039 "src/ocaml/preprocess/parser_raw.ml" +# 2327 "src/ocaml/preprocess/parser_raw.ml" in -# 3588 "src/ocaml/preprocess/parser_raw.mly" +# 3784 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3045 "src/ocaml/preprocess/parser_raw.ml" +# 2333 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3059,29 +2347,29 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let _1 : (Parsetree.extension) = Obj.magic _1 in + let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.core_type) = let _1 = let _1 = -# 3586 "src/ocaml/preprocess/parser_raw.mly" - ( Ptyp_extension _1 ) -# 3071 "src/ocaml/preprocess/parser_raw.ml" +# 3782 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_any ) +# 2359 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 3079 "src/ocaml/preprocess/parser_raw.ml" +# 2367 "src/ocaml/preprocess/parser_raw.ml" in -# 3588 "src/ocaml/preprocess/parser_raw.mly" +# 3784 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3085 "src/ocaml/preprocess/parser_raw.ml" +# 2373 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3105,23 +2393,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (string Location.loc) = let _1 = let _1 = -# 4008 "src/ocaml/preprocess/parser_raw.mly" +# 4204 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3111 "src/ocaml/preprocess/parser_raw.ml" +# 2399 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1020 "src/ocaml/preprocess/parser_raw.mly" +# 1057 "src/ocaml/preprocess/parser_raw.mly" ( mkloc _1 (make_loc _sloc) ) -# 3119 "src/ocaml/preprocess/parser_raw.ml" +# 2407 "src/ocaml/preprocess/parser_raw.ml" in -# 4010 "src/ocaml/preprocess/parser_raw.mly" +# 4206 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3125 "src/ocaml/preprocess/parser_raw.ml" +# 2413 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3159,24 +2447,51 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (string Location.loc) = let _1 = let _1 = -# 4009 "src/ocaml/preprocess/parser_raw.mly" +# 4205 "src/ocaml/preprocess/parser_raw.mly" ( _1 ^ "." ^ _3.txt ) -# 3165 "src/ocaml/preprocess/parser_raw.ml" +# 2453 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1020 "src/ocaml/preprocess/parser_raw.mly" +# 1057 "src/ocaml/preprocess/parser_raw.mly" ( mkloc _1 (make_loc _sloc) ) -# 3174 "src/ocaml/preprocess/parser_raw.ml" +# 2462 "src/ocaml/preprocess/parser_raw.ml" in -# 4010 "src/ocaml/preprocess/parser_raw.mly" +# 4206 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3180 "src/ocaml/preprocess/parser_raw.ml" +# 2468 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + } = _menhir_stack in + let _1 : (Parsetree.payload) = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_ in + let _v : (Parsetree.payload) = +# 4261 "src/ocaml/preprocess/parser_raw.mly" + ( Builtin_attributes.mark_payload_attrs_used _1; + _1 + ) +# 2495 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3223,9 +2538,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 4014 "src/ocaml/preprocess/parser_raw.mly" - ( Attr.mk ~loc:(make_loc _sloc) _2 _3 ) -# 3229 "src/ocaml/preprocess/parser_raw.ml" +# 4210 "src/ocaml/preprocess/parser_raw.mly" + ( mk_attr ~loc:(make_loc _sloc) _2 _3 ) +# 2544 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3248,9 +2563,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.class_expr) = -# 1994 "src/ocaml/preprocess/parser_raw.mly" +# 2069 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3254 "src/ocaml/preprocess/parser_raw.ml" +# 2569 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3289,18 +2604,18 @@ module Tables = struct let _v : (Parsetree.class_expr) = let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3295 "src/ocaml/preprocess/parser_raw.ml" +# 2610 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__3_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1996 "src/ocaml/preprocess/parser_raw.mly" +# 2071 "src/ocaml/preprocess/parser_raw.mly" ( wrap_class_attrs ~loc:_sloc _3 _2 ) -# 3304 "src/ocaml/preprocess/parser_raw.ml" +# 2619 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3340,9 +2655,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1998 "src/ocaml/preprocess/parser_raw.mly" +# 2073 "src/ocaml/preprocess/parser_raw.mly" ( class_of_let_bindings ~loc:_sloc _1 _3 ) -# 3346 "src/ocaml/preprocess/parser_raw.ml" +# 2661 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3405,34 +2720,34 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 3411 "src/ocaml/preprocess/parser_raw.ml" +# 2726 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__5_ = _endpos__1_inlined2_ in let _4 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3420 "src/ocaml/preprocess/parser_raw.ml" +# 2735 "src/ocaml/preprocess/parser_raw.ml" in let _3 = -# 3933 "src/ocaml/preprocess/parser_raw.mly" +# 4129 "src/ocaml/preprocess/parser_raw.mly" ( Fresh ) -# 3426 "src/ocaml/preprocess/parser_raw.ml" +# 2741 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2000 "src/ocaml/preprocess/parser_raw.mly" +# 2075 "src/ocaml/preprocess/parser_raw.mly" ( let loc = (_startpos__2_, _endpos__5_) in let od = Opn.mk ~override:_3 ~loc:(make_loc loc) _5 in mkclass ~loc:_sloc ~attrs:_4 (Pcl_open(od, _7)) ) -# 3436 "src/ocaml/preprocess/parser_raw.ml" +# 2751 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3502,37 +2817,37 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 3508 "src/ocaml/preprocess/parser_raw.ml" +# 2823 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__5_ = _endpos__1_inlined3_ in let _4 = let _1 = _1_inlined2 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3517 "src/ocaml/preprocess/parser_raw.ml" +# 2832 "src/ocaml/preprocess/parser_raw.ml" in let _3 = let _1 = _1_inlined1 in -# 3934 "src/ocaml/preprocess/parser_raw.mly" +# 4130 "src/ocaml/preprocess/parser_raw.mly" ( Override ) -# 3525 "src/ocaml/preprocess/parser_raw.ml" +# 2840 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2000 "src/ocaml/preprocess/parser_raw.mly" +# 2075 "src/ocaml/preprocess/parser_raw.mly" ( let loc = (_startpos__2_, _endpos__5_) in let od = Opn.mk ~override:_3 ~loc:(make_loc loc) _5 in mkclass ~loc:_sloc ~attrs:_4 (Pcl_open(od, _7)) ) -# 3536 "src/ocaml/preprocess/parser_raw.ml" +# 2851 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3562,9 +2877,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.class_expr) = -# 2004 "src/ocaml/preprocess/parser_raw.mly" +# 2079 "src/ocaml/preprocess/parser_raw.mly" ( Cl.attr _1 _2 ) -# 3568 "src/ocaml/preprocess/parser_raw.ml" +# 2883 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3599,18 +2914,18 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 3603 "src/ocaml/preprocess/parser_raw.ml" +# 2918 "src/ocaml/preprocess/parser_raw.ml" in -# 1092 "src/ocaml/preprocess/parser_raw.mly" +# 1129 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 3608 "src/ocaml/preprocess/parser_raw.ml" +# 2923 "src/ocaml/preprocess/parser_raw.ml" in -# 2007 "src/ocaml/preprocess/parser_raw.mly" +# 2082 "src/ocaml/preprocess/parser_raw.mly" ( Pcl_apply(_1, _2) ) -# 3614 "src/ocaml/preprocess/parser_raw.ml" +# 2929 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos_xs_ in @@ -3618,15 +2933,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1043 "src/ocaml/preprocess/parser_raw.mly" +# 1080 "src/ocaml/preprocess/parser_raw.mly" ( mkclass ~loc:_sloc _1 ) -# 3624 "src/ocaml/preprocess/parser_raw.ml" +# 2939 "src/ocaml/preprocess/parser_raw.ml" in -# 2010 "src/ocaml/preprocess/parser_raw.mly" +# 2085 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3630 "src/ocaml/preprocess/parser_raw.ml" +# 2945 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3650,23 +2965,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.class_expr) = let _1 = let _1 = -# 2009 "src/ocaml/preprocess/parser_raw.mly" +# 2084 "src/ocaml/preprocess/parser_raw.mly" ( Pcl_extension _1 ) -# 3656 "src/ocaml/preprocess/parser_raw.ml" +# 2971 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1043 "src/ocaml/preprocess/parser_raw.mly" +# 1080 "src/ocaml/preprocess/parser_raw.mly" ( mkclass ~loc:_sloc _1 ) -# 3664 "src/ocaml/preprocess/parser_raw.ml" +# 2979 "src/ocaml/preprocess/parser_raw.ml" in -# 2010 "src/ocaml/preprocess/parser_raw.mly" +# 2085 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3670 "src/ocaml/preprocess/parser_raw.ml" +# 2985 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3719,33 +3034,33 @@ module Tables = struct let _v : (Parsetree.class_field) = let _6 = let _1 = _1_inlined2 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3725 "src/ocaml/preprocess/parser_raw.ml" +# 3040 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__6_ = _endpos__1_inlined2_ in let _3 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3734 "src/ocaml/preprocess/parser_raw.ml" +# 3049 "src/ocaml/preprocess/parser_raw.ml" in let _2 = -# 3933 "src/ocaml/preprocess/parser_raw.mly" +# 4129 "src/ocaml/preprocess/parser_raw.mly" ( Fresh ) -# 3740 "src/ocaml/preprocess/parser_raw.ml" +# 3055 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__6_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2065 "src/ocaml/preprocess/parser_raw.mly" +# 2140 "src/ocaml/preprocess/parser_raw.mly" ( let docs = symbol_docs _sloc in mkcf ~loc:_sloc (Pcf_inherit (_2, _4, self)) ~attrs:(_3@_6) ~docs ) -# 3749 "src/ocaml/preprocess/parser_raw.ml" +# 3064 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3805,36 +3120,36 @@ module Tables = struct let _v : (Parsetree.class_field) = let _6 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3811 "src/ocaml/preprocess/parser_raw.ml" +# 3126 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__6_ = _endpos__1_inlined3_ in let _3 = let _1 = _1_inlined2 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3820 "src/ocaml/preprocess/parser_raw.ml" +# 3135 "src/ocaml/preprocess/parser_raw.ml" in let _2 = let _1 = _1_inlined1 in -# 3934 "src/ocaml/preprocess/parser_raw.mly" +# 4130 "src/ocaml/preprocess/parser_raw.mly" ( Override ) -# 3828 "src/ocaml/preprocess/parser_raw.ml" +# 3143 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__6_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2065 "src/ocaml/preprocess/parser_raw.mly" +# 2140 "src/ocaml/preprocess/parser_raw.mly" ( let docs = symbol_docs _sloc in mkcf ~loc:_sloc (Pcf_inherit (_2, _4, self)) ~attrs:(_3@_6) ~docs ) -# 3838 "src/ocaml/preprocess/parser_raw.ml" +# 3153 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3874,9 +3189,9 @@ module Tables = struct let _v : (Parsetree.class_field) = let _3 = let _1 = _1_inlined1 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3880 "src/ocaml/preprocess/parser_raw.ml" +# 3195 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__3_ = _endpos__1_inlined1_ in @@ -3884,11 +3199,11 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2068 "src/ocaml/preprocess/parser_raw.mly" +# 2143 "src/ocaml/preprocess/parser_raw.mly" ( let v, attrs = _2 in let docs = symbol_docs _sloc in mkcf ~loc:_sloc (Pcf_val v) ~attrs:(attrs@_3) ~docs ) -# 3892 "src/ocaml/preprocess/parser_raw.ml" +# 3207 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3928,9 +3243,9 @@ module Tables = struct let _v : (Parsetree.class_field) = let _3 = let _1 = _1_inlined1 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3934 "src/ocaml/preprocess/parser_raw.ml" +# 3249 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__3_ = _endpos__1_inlined1_ in @@ -3938,11 +3253,11 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2072 "src/ocaml/preprocess/parser_raw.mly" +# 2147 "src/ocaml/preprocess/parser_raw.mly" ( let meth, attrs = _2 in let docs = symbol_docs _sloc in mkcf ~loc:_sloc (Pcf_method meth) ~attrs:(attrs@_3) ~docs ) -# 3946 "src/ocaml/preprocess/parser_raw.ml" +# 3261 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -3988,28 +3303,28 @@ module Tables = struct let _v : (Parsetree.class_field) = let _4 = let _1 = _1_inlined2 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 3994 "src/ocaml/preprocess/parser_raw.ml" +# 3309 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__4_ = _endpos__1_inlined2_ in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4003 "src/ocaml/preprocess/parser_raw.ml" +# 3318 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2076 "src/ocaml/preprocess/parser_raw.mly" +# 2151 "src/ocaml/preprocess/parser_raw.mly" ( let docs = symbol_docs _sloc in mkcf ~loc:_sloc (Pcf_constraint _3) ~attrs:(_2@_4) ~docs ) -# 4013 "src/ocaml/preprocess/parser_raw.ml" +# 3328 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4055,28 +3370,28 @@ module Tables = struct let _v : (Parsetree.class_field) = let _4 = let _1 = _1_inlined2 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4061 "src/ocaml/preprocess/parser_raw.ml" +# 3376 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__4_ = _endpos__1_inlined2_ in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4070 "src/ocaml/preprocess/parser_raw.ml" +# 3385 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2079 "src/ocaml/preprocess/parser_raw.mly" +# 2154 "src/ocaml/preprocess/parser_raw.mly" ( let docs = symbol_docs _sloc in mkcf ~loc:_sloc (Pcf_initializer _3) ~attrs:(_2@_4) ~docs ) -# 4080 "src/ocaml/preprocess/parser_raw.ml" +# 3395 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4108,9 +3423,9 @@ module Tables = struct let _v : (Parsetree.class_field) = let _2 = let _1 = _1_inlined1 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4114 "src/ocaml/preprocess/parser_raw.ml" +# 3429 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__2_ = _endpos__1_inlined1_ in @@ -4118,10 +3433,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2082 "src/ocaml/preprocess/parser_raw.mly" +# 2157 "src/ocaml/preprocess/parser_raw.mly" ( let docs = symbol_docs _sloc in mkcf ~loc:_sloc (Pcf_extension _1) ~attrs:_2 ~docs ) -# 4125 "src/ocaml/preprocess/parser_raw.ml" +# 3440 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4145,23 +3460,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.class_field) = let _1 = let _1 = -# 2085 "src/ocaml/preprocess/parser_raw.mly" +# 2160 "src/ocaml/preprocess/parser_raw.mly" ( Pcf_attribute _1 ) -# 4151 "src/ocaml/preprocess/parser_raw.ml" +# 3466 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1041 "src/ocaml/preprocess/parser_raw.mly" +# 1078 "src/ocaml/preprocess/parser_raw.mly" ( mkcf ~loc:_sloc _1 ) -# 4159 "src/ocaml/preprocess/parser_raw.ml" +# 3474 "src/ocaml/preprocess/parser_raw.ml" in -# 2086 "src/ocaml/preprocess/parser_raw.mly" +# 2161 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4165 "src/ocaml/preprocess/parser_raw.ml" +# 3480 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4191,9 +3506,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.class_expr) = -# 1974 "src/ocaml/preprocess/parser_raw.mly" +# 2049 "src/ocaml/preprocess/parser_raw.mly" ( _2 ) -# 4197 "src/ocaml/preprocess/parser_raw.ml" +# 3512 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4238,24 +3553,24 @@ module Tables = struct let _endpos = _endpos__4_ in let _v : (Parsetree.class_expr) = let _1 = let _1 = -# 1977 "src/ocaml/preprocess/parser_raw.mly" +# 2052 "src/ocaml/preprocess/parser_raw.mly" ( Pcl_constraint(_4, _2) ) -# 4244 "src/ocaml/preprocess/parser_raw.ml" +# 3559 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__4_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1043 "src/ocaml/preprocess/parser_raw.mly" +# 1080 "src/ocaml/preprocess/parser_raw.mly" ( mkclass ~loc:_sloc _1 ) -# 4253 "src/ocaml/preprocess/parser_raw.ml" +# 3568 "src/ocaml/preprocess/parser_raw.ml" in -# 1980 "src/ocaml/preprocess/parser_raw.mly" +# 2055 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4259 "src/ocaml/preprocess/parser_raw.ml" +# 3574 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4286,24 +3601,24 @@ module Tables = struct let _endpos = _endpos__2_ in let _v : (Parsetree.class_expr) = let _1 = let _1 = -# 1979 "src/ocaml/preprocess/parser_raw.mly" +# 2054 "src/ocaml/preprocess/parser_raw.mly" ( let (l,o,p) = _1 in Pcl_fun(l, o, p, _2) ) -# 4292 "src/ocaml/preprocess/parser_raw.ml" +# 3607 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1043 "src/ocaml/preprocess/parser_raw.mly" +# 1080 "src/ocaml/preprocess/parser_raw.mly" ( mkclass ~loc:_sloc _1 ) -# 4301 "src/ocaml/preprocess/parser_raw.ml" +# 3616 "src/ocaml/preprocess/parser_raw.ml" in -# 1980 "src/ocaml/preprocess/parser_raw.mly" +# 2055 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4307 "src/ocaml/preprocess/parser_raw.ml" +# 3622 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4341,24 +3656,24 @@ module Tables = struct let _endpos = _endpos_e_ in let _v : (Parsetree.class_expr) = let _1 = let _1 = -# 2041 "src/ocaml/preprocess/parser_raw.mly" +# 2116 "src/ocaml/preprocess/parser_raw.mly" ( let (l,o,p) = _1 in Pcl_fun(l, o, p, e) ) -# 4347 "src/ocaml/preprocess/parser_raw.ml" +# 3662 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos_e_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1043 "src/ocaml/preprocess/parser_raw.mly" +# 1080 "src/ocaml/preprocess/parser_raw.mly" ( mkclass ~loc:_sloc _1 ) -# 4356 "src/ocaml/preprocess/parser_raw.ml" +# 3671 "src/ocaml/preprocess/parser_raw.ml" in -# 2042 "src/ocaml/preprocess/parser_raw.mly" +# 2117 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4362 "src/ocaml/preprocess/parser_raw.ml" +# 3677 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4389,24 +3704,24 @@ module Tables = struct let _endpos = _endpos_e_ in let _v : (Parsetree.class_expr) = let _1 = let _1 = -# 2041 "src/ocaml/preprocess/parser_raw.mly" +# 2116 "src/ocaml/preprocess/parser_raw.mly" ( let (l,o,p) = _1 in Pcl_fun(l, o, p, e) ) -# 4395 "src/ocaml/preprocess/parser_raw.ml" +# 3710 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos_e_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1043 "src/ocaml/preprocess/parser_raw.mly" +# 1080 "src/ocaml/preprocess/parser_raw.mly" ( mkclass ~loc:_sloc _1 ) -# 4404 "src/ocaml/preprocess/parser_raw.ml" +# 3719 "src/ocaml/preprocess/parser_raw.ml" in -# 2042 "src/ocaml/preprocess/parser_raw.mly" +# 2117 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4410 "src/ocaml/preprocess/parser_raw.ml" +# 3725 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4429,9 +3744,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3815 "src/ocaml/preprocess/parser_raw.mly" +# 4011 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4435 "src/ocaml/preprocess/parser_raw.ml" +# 3750 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4471,9 +3786,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2050 "src/ocaml/preprocess/parser_raw.mly" +# 2125 "src/ocaml/preprocess/parser_raw.mly" ( reloc_pat ~loc:_sloc _2 ) -# 4477 "src/ocaml/preprocess/parser_raw.ml" +# 3792 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4525,24 +3840,24 @@ module Tables = struct let _endpos = _endpos__5_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2052 "src/ocaml/preprocess/parser_raw.mly" +# 2127 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_constraint(_2, _4) ) -# 4531 "src/ocaml/preprocess/parser_raw.ml" +# 3846 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__5_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 4540 "src/ocaml/preprocess/parser_raw.ml" +# 3855 "src/ocaml/preprocess/parser_raw.ml" in -# 2053 "src/ocaml/preprocess/parser_raw.mly" +# 2128 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4546 "src/ocaml/preprocess/parser_raw.ml" +# 3861 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4561,9 +3876,9 @@ module Tables = struct let _symbolstartpos = _endpos in let _sloc = (_symbolstartpos, _endpos) in -# 2055 "src/ocaml/preprocess/parser_raw.mly" +# 2130 "src/ocaml/preprocess/parser_raw.mly" ( ghpat ~loc:_sloc Ppat_any ) -# 4567 "src/ocaml/preprocess/parser_raw.ml" +# 3882 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4600,9 +3915,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.core_type) = -# 2182 "src/ocaml/preprocess/parser_raw.mly" +# 2257 "src/ocaml/preprocess/parser_raw.mly" ( _2 ) -# 4606 "src/ocaml/preprocess/parser_raw.ml" +# 3921 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4619,24 +3934,24 @@ module Tables = struct let _endpos = _startpos in let _v : (Parsetree.core_type) = let _1 = let _1 = -# 2183 "src/ocaml/preprocess/parser_raw.mly" +# 2258 "src/ocaml/preprocess/parser_raw.mly" ( Ptyp_any ) -# 4625 "src/ocaml/preprocess/parser_raw.ml" +# 3940 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__0_ in let _endpos = _endpos__1_ in let _symbolstartpos = _endpos in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 4634 "src/ocaml/preprocess/parser_raw.ml" +# 3949 "src/ocaml/preprocess/parser_raw.ml" in -# 2184 "src/ocaml/preprocess/parser_raw.mly" +# 2259 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4640 "src/ocaml/preprocess/parser_raw.ml" +# 3955 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4682,28 +3997,28 @@ module Tables = struct let _v : (Parsetree.class_type_field) = let _4 = let _1 = _1_inlined2 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4688 "src/ocaml/preprocess/parser_raw.ml" +# 4003 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__4_ = _endpos__1_inlined2_ in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4697 "src/ocaml/preprocess/parser_raw.ml" +# 4012 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2192 "src/ocaml/preprocess/parser_raw.mly" +# 2267 "src/ocaml/preprocess/parser_raw.mly" ( let docs = symbol_docs _sloc in mkctf ~loc:_sloc (Pctf_inherit _3) ~attrs:(_2@_4) ~docs ) -# 4707 "src/ocaml/preprocess/parser_raw.ml" +# 4022 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4761,9 +4076,9 @@ module Tables = struct let ty : (Parsetree.core_type) = Obj.magic ty in let _3 : unit = Obj.magic _3 in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 4767 "src/ocaml/preprocess/parser_raw.ml" +# 4082 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let flags : (Asttypes.mutable_flag * Asttypes.virtual_flag) = Obj.magic flags in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in @@ -4774,9 +4089,9 @@ module Tables = struct let _v : (Parsetree.class_type_field) = let _4 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4780 "src/ocaml/preprocess/parser_raw.ml" +# 4095 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__4_ = _endpos__1_inlined3_ in @@ -4784,44 +4099,44 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let label = let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4790 "src/ocaml/preprocess/parser_raw.ml" +# 4105 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 4798 "src/ocaml/preprocess/parser_raw.ml" +# 4113 "src/ocaml/preprocess/parser_raw.ml" in -# 2217 "src/ocaml/preprocess/parser_raw.mly" +# 2292 "src/ocaml/preprocess/parser_raw.mly" ( let mut, virt = flags in label, mut, virt, ty ) -# 4807 "src/ocaml/preprocess/parser_raw.ml" +# 4122 "src/ocaml/preprocess/parser_raw.ml" in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4815 "src/ocaml/preprocess/parser_raw.ml" +# 4130 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2195 "src/ocaml/preprocess/parser_raw.mly" +# 2270 "src/ocaml/preprocess/parser_raw.mly" ( let docs = symbol_docs _sloc in mkctf ~loc:_sloc (Pctf_val _3) ~attrs:(_2@_4) ~docs ) -# 4825 "src/ocaml/preprocess/parser_raw.ml" +# 4140 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4879,9 +4194,9 @@ module Tables = struct let _1_inlined3 : (Parsetree.core_type) = Obj.magic _1_inlined3 in let _5 : unit = Obj.magic _5 in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 4885 "src/ocaml/preprocess/parser_raw.ml" +# 4200 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let _3 : (Asttypes.private_flag * Asttypes.virtual_flag) = Obj.magic _3 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in @@ -4892,53 +4207,53 @@ module Tables = struct let _v : (Parsetree.class_type_field) = let _7 = let _1 = _1_inlined4 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4898 "src/ocaml/preprocess/parser_raw.ml" +# 4213 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__7_ = _endpos__1_inlined4_ in let _6 = let _1 = _1_inlined3 in -# 3456 "src/ocaml/preprocess/parser_raw.mly" +# 3596 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4907 "src/ocaml/preprocess/parser_raw.ml" +# 4222 "src/ocaml/preprocess/parser_raw.ml" in let _4 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4915 "src/ocaml/preprocess/parser_raw.ml" +# 4230 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 4923 "src/ocaml/preprocess/parser_raw.ml" +# 4238 "src/ocaml/preprocess/parser_raw.ml" in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4931 "src/ocaml/preprocess/parser_raw.ml" +# 4246 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2199 "src/ocaml/preprocess/parser_raw.mly" +# 2274 "src/ocaml/preprocess/parser_raw.mly" ( let (p, v) = _3 in let docs = symbol_docs _sloc in mkctf ~loc:_sloc (Pctf_method (_4, p, v, _6)) ~attrs:(_2@_7) ~docs ) -# 4942 "src/ocaml/preprocess/parser_raw.ml" +# 4257 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -4984,28 +4299,28 @@ module Tables = struct let _v : (Parsetree.class_type_field) = let _4 = let _1 = _1_inlined2 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4990 "src/ocaml/preprocess/parser_raw.ml" +# 4305 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__4_ = _endpos__1_inlined2_ in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 4999 "src/ocaml/preprocess/parser_raw.ml" +# 4314 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2203 "src/ocaml/preprocess/parser_raw.mly" +# 2278 "src/ocaml/preprocess/parser_raw.mly" ( let docs = symbol_docs _sloc in mkctf ~loc:_sloc (Pctf_constraint _3) ~attrs:(_2@_4) ~docs ) -# 5009 "src/ocaml/preprocess/parser_raw.ml" +# 4324 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5037,9 +4352,9 @@ module Tables = struct let _v : (Parsetree.class_type_field) = let _2 = let _1 = _1_inlined1 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 5043 "src/ocaml/preprocess/parser_raw.ml" +# 4358 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__2_ = _endpos__1_inlined1_ in @@ -5047,10 +4362,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2206 "src/ocaml/preprocess/parser_raw.mly" +# 2281 "src/ocaml/preprocess/parser_raw.mly" ( let docs = symbol_docs _sloc in mkctf ~loc:_sloc (Pctf_extension _1) ~attrs:_2 ~docs ) -# 5054 "src/ocaml/preprocess/parser_raw.ml" +# 4369 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5074,23 +4389,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.class_type_field) = let _1 = let _1 = -# 2209 "src/ocaml/preprocess/parser_raw.mly" +# 2284 "src/ocaml/preprocess/parser_raw.mly" ( Pctf_attribute _1 ) -# 5080 "src/ocaml/preprocess/parser_raw.ml" +# 4395 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1039 "src/ocaml/preprocess/parser_raw.mly" +# 1076 "src/ocaml/preprocess/parser_raw.mly" ( mkctf ~loc:_sloc _1 ) -# 5088 "src/ocaml/preprocess/parser_raw.ml" +# 4403 "src/ocaml/preprocess/parser_raw.ml" in -# 2210 "src/ocaml/preprocess/parser_raw.mly" +# 2285 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 5094 "src/ocaml/preprocess/parser_raw.ml" +# 4409 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5119,42 +4434,42 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 5125 "src/ocaml/preprocess/parser_raw.ml" +# 4440 "src/ocaml/preprocess/parser_raw.ml" in let tys = let tys = -# 2168 "src/ocaml/preprocess/parser_raw.mly" +# 2243 "src/ocaml/preprocess/parser_raw.mly" ( [] ) -# 5132 "src/ocaml/preprocess/parser_raw.ml" +# 4447 "src/ocaml/preprocess/parser_raw.ml" in -# 2174 "src/ocaml/preprocess/parser_raw.mly" +# 2249 "src/ocaml/preprocess/parser_raw.mly" ( tys ) -# 5137 "src/ocaml/preprocess/parser_raw.ml" +# 4452 "src/ocaml/preprocess/parser_raw.ml" in -# 2149 "src/ocaml/preprocess/parser_raw.mly" +# 2224 "src/ocaml/preprocess/parser_raw.mly" ( Pcty_constr (cid, tys) ) -# 5143 "src/ocaml/preprocess/parser_raw.ml" +# 4458 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1037 "src/ocaml/preprocess/parser_raw.mly" +# 1074 "src/ocaml/preprocess/parser_raw.mly" ( mkcty ~loc:_sloc _1 ) -# 5152 "src/ocaml/preprocess/parser_raw.ml" +# 4467 "src/ocaml/preprocess/parser_raw.ml" in -# 2152 "src/ocaml/preprocess/parser_raw.mly" +# 2227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 5158 "src/ocaml/preprocess/parser_raw.ml" +# 4473 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5205,9 +4520,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 5211 "src/ocaml/preprocess/parser_raw.ml" +# 4526 "src/ocaml/preprocess/parser_raw.ml" in let tys = @@ -5216,30 +4531,30 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 5220 "src/ocaml/preprocess/parser_raw.ml" +# 4535 "src/ocaml/preprocess/parser_raw.ml" in -# 1124 "src/ocaml/preprocess/parser_raw.mly" +# 1182 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 5225 "src/ocaml/preprocess/parser_raw.ml" +# 4540 "src/ocaml/preprocess/parser_raw.ml" in -# 2170 "src/ocaml/preprocess/parser_raw.mly" +# 2245 "src/ocaml/preprocess/parser_raw.mly" ( params ) -# 5231 "src/ocaml/preprocess/parser_raw.ml" +# 4546 "src/ocaml/preprocess/parser_raw.ml" in -# 2174 "src/ocaml/preprocess/parser_raw.mly" +# 2249 "src/ocaml/preprocess/parser_raw.mly" ( tys ) -# 5237 "src/ocaml/preprocess/parser_raw.ml" +# 4552 "src/ocaml/preprocess/parser_raw.ml" in -# 2149 "src/ocaml/preprocess/parser_raw.mly" +# 2224 "src/ocaml/preprocess/parser_raw.mly" ( Pcty_constr (cid, tys) ) -# 5243 "src/ocaml/preprocess/parser_raw.ml" +# 4558 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -5247,15 +4562,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1037 "src/ocaml/preprocess/parser_raw.mly" +# 1074 "src/ocaml/preprocess/parser_raw.mly" ( mkcty ~loc:_sloc _1 ) -# 5253 "src/ocaml/preprocess/parser_raw.ml" +# 4568 "src/ocaml/preprocess/parser_raw.ml" in -# 2152 "src/ocaml/preprocess/parser_raw.mly" +# 2227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 5259 "src/ocaml/preprocess/parser_raw.ml" +# 4574 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5279,23 +4594,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.class_type) = let _1 = let _1 = -# 2151 "src/ocaml/preprocess/parser_raw.mly" +# 2226 "src/ocaml/preprocess/parser_raw.mly" ( Pcty_extension _1 ) -# 5285 "src/ocaml/preprocess/parser_raw.ml" +# 4600 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1037 "src/ocaml/preprocess/parser_raw.mly" +# 1074 "src/ocaml/preprocess/parser_raw.mly" ( mkcty ~loc:_sloc _1 ) -# 5293 "src/ocaml/preprocess/parser_raw.ml" +# 4608 "src/ocaml/preprocess/parser_raw.ml" in -# 2152 "src/ocaml/preprocess/parser_raw.mly" +# 2227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 5299 "src/ocaml/preprocess/parser_raw.ml" +# 4614 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5352,44 +4667,44 @@ module Tables = struct let _1 = # 260 "" ( List.flatten xss ) -# 5356 "src/ocaml/preprocess/parser_raw.ml" +# 4671 "src/ocaml/preprocess/parser_raw.ml" in -# 2188 "src/ocaml/preprocess/parser_raw.mly" +# 2263 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 5361 "src/ocaml/preprocess/parser_raw.ml" +# 4676 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 985 "src/ocaml/preprocess/parser_raw.mly" +# 1022 "src/ocaml/preprocess/parser_raw.mly" ( extra_csig _startpos _endpos _1 ) -# 5370 "src/ocaml/preprocess/parser_raw.ml" +# 4685 "src/ocaml/preprocess/parser_raw.ml" in -# 2178 "src/ocaml/preprocess/parser_raw.mly" +# 2253 "src/ocaml/preprocess/parser_raw.mly" ( Csig.mk _1 _2 ) -# 5376 "src/ocaml/preprocess/parser_raw.ml" +# 4691 "src/ocaml/preprocess/parser_raw.ml" in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 5384 "src/ocaml/preprocess/parser_raw.ml" +# 4699 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2154 "src/ocaml/preprocess/parser_raw.mly" +# 2229 "src/ocaml/preprocess/parser_raw.mly" ( mkcty ~loc:_sloc ~attrs:_2 (Pcty_signature _3) ) -# 5393 "src/ocaml/preprocess/parser_raw.ml" +# 4708 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5419,9 +4734,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.class_type) = -# 2160 "src/ocaml/preprocess/parser_raw.mly" +# 2235 "src/ocaml/preprocess/parser_raw.mly" ( Cty.attr _1 _2 ) -# 5425 "src/ocaml/preprocess/parser_raw.ml" +# 4740 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5484,34 +4799,34 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 5490 "src/ocaml/preprocess/parser_raw.ml" +# 4805 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__5_ = _endpos__1_inlined2_ in let _4 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 5499 "src/ocaml/preprocess/parser_raw.ml" +# 4814 "src/ocaml/preprocess/parser_raw.ml" in let _3 = -# 3933 "src/ocaml/preprocess/parser_raw.mly" +# 4129 "src/ocaml/preprocess/parser_raw.mly" ( Fresh ) -# 5505 "src/ocaml/preprocess/parser_raw.ml" +# 4820 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2162 "src/ocaml/preprocess/parser_raw.mly" +# 2237 "src/ocaml/preprocess/parser_raw.mly" ( let loc = (_startpos__2_, _endpos__5_) in let od = Opn.mk ~override:_3 ~loc:(make_loc loc) _5 in mkcty ~loc:_sloc ~attrs:_4 (Pcty_open(od, _7)) ) -# 5515 "src/ocaml/preprocess/parser_raw.ml" +# 4830 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5581,37 +4896,37 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 5587 "src/ocaml/preprocess/parser_raw.ml" +# 4902 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__5_ = _endpos__1_inlined3_ in let _4 = let _1 = _1_inlined2 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 5596 "src/ocaml/preprocess/parser_raw.ml" +# 4911 "src/ocaml/preprocess/parser_raw.ml" in let _3 = let _1 = _1_inlined1 in -# 3934 "src/ocaml/preprocess/parser_raw.mly" +# 4130 "src/ocaml/preprocess/parser_raw.mly" ( Override ) -# 5604 "src/ocaml/preprocess/parser_raw.ml" +# 4919 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2162 "src/ocaml/preprocess/parser_raw.mly" +# 2237 "src/ocaml/preprocess/parser_raw.mly" ( let loc = (_startpos__2_, _endpos__5_) in let od = Opn.mk ~override:_3 ~loc:(make_loc loc) _5 in mkcty ~loc:_sloc ~attrs:_4 (Pcty_open(od, _7)) ) -# 5615 "src/ocaml/preprocess/parser_raw.ml" +# 4930 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5648,9 +4963,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.class_expr) = -# 2014 "src/ocaml/preprocess/parser_raw.mly" +# 2089 "src/ocaml/preprocess/parser_raw.mly" ( _2 ) -# 5654 "src/ocaml/preprocess/parser_raw.ml" +# 4969 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5679,42 +4994,42 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 5685 "src/ocaml/preprocess/parser_raw.ml" +# 5000 "src/ocaml/preprocess/parser_raw.ml" in let tys = let tys = -# 2168 "src/ocaml/preprocess/parser_raw.mly" +# 2243 "src/ocaml/preprocess/parser_raw.mly" ( [] ) -# 5692 "src/ocaml/preprocess/parser_raw.ml" +# 5007 "src/ocaml/preprocess/parser_raw.ml" in -# 2174 "src/ocaml/preprocess/parser_raw.mly" +# 2249 "src/ocaml/preprocess/parser_raw.mly" ( tys ) -# 5697 "src/ocaml/preprocess/parser_raw.ml" +# 5012 "src/ocaml/preprocess/parser_raw.ml" in -# 2021 "src/ocaml/preprocess/parser_raw.mly" +# 2096 "src/ocaml/preprocess/parser_raw.mly" ( Pcl_constr(cid, tys) ) -# 5703 "src/ocaml/preprocess/parser_raw.ml" +# 5018 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1043 "src/ocaml/preprocess/parser_raw.mly" +# 1080 "src/ocaml/preprocess/parser_raw.mly" ( mkclass ~loc:_sloc _1 ) -# 5712 "src/ocaml/preprocess/parser_raw.ml" +# 5027 "src/ocaml/preprocess/parser_raw.ml" in -# 2032 "src/ocaml/preprocess/parser_raw.mly" +# 2107 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 5718 "src/ocaml/preprocess/parser_raw.ml" +# 5033 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5765,9 +5080,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 5771 "src/ocaml/preprocess/parser_raw.ml" +# 5086 "src/ocaml/preprocess/parser_raw.ml" in let tys = @@ -5776,30 +5091,30 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 5780 "src/ocaml/preprocess/parser_raw.ml" +# 5095 "src/ocaml/preprocess/parser_raw.ml" in -# 1124 "src/ocaml/preprocess/parser_raw.mly" +# 1182 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 5785 "src/ocaml/preprocess/parser_raw.ml" +# 5100 "src/ocaml/preprocess/parser_raw.ml" in -# 2170 "src/ocaml/preprocess/parser_raw.mly" +# 2245 "src/ocaml/preprocess/parser_raw.mly" ( params ) -# 5791 "src/ocaml/preprocess/parser_raw.ml" +# 5106 "src/ocaml/preprocess/parser_raw.ml" in -# 2174 "src/ocaml/preprocess/parser_raw.mly" +# 2249 "src/ocaml/preprocess/parser_raw.mly" ( tys ) -# 5797 "src/ocaml/preprocess/parser_raw.ml" +# 5112 "src/ocaml/preprocess/parser_raw.ml" in -# 2021 "src/ocaml/preprocess/parser_raw.mly" +# 2096 "src/ocaml/preprocess/parser_raw.mly" ( Pcl_constr(cid, tys) ) -# 5803 "src/ocaml/preprocess/parser_raw.ml" +# 5118 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -5807,15 +5122,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1043 "src/ocaml/preprocess/parser_raw.mly" +# 1080 "src/ocaml/preprocess/parser_raw.mly" ( mkclass ~loc:_sloc _1 ) -# 5813 "src/ocaml/preprocess/parser_raw.ml" +# 5128 "src/ocaml/preprocess/parser_raw.ml" in -# 2032 "src/ocaml/preprocess/parser_raw.mly" +# 2107 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 5819 "src/ocaml/preprocess/parser_raw.ml" +# 5134 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5867,24 +5182,24 @@ module Tables = struct let _endpos = _endpos__5_ in let _v : (Parsetree.class_expr) = let _1 = let _1 = -# 2027 "src/ocaml/preprocess/parser_raw.mly" +# 2102 "src/ocaml/preprocess/parser_raw.mly" ( Pcl_constraint(_2, _4) ) -# 5873 "src/ocaml/preprocess/parser_raw.ml" +# 5188 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__5_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1043 "src/ocaml/preprocess/parser_raw.mly" +# 1080 "src/ocaml/preprocess/parser_raw.mly" ( mkclass ~loc:_sloc _1 ) -# 5882 "src/ocaml/preprocess/parser_raw.ml" +# 5197 "src/ocaml/preprocess/parser_raw.ml" in -# 2032 "src/ocaml/preprocess/parser_raw.mly" +# 2107 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 5888 "src/ocaml/preprocess/parser_raw.ml" +# 5203 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -5941,44 +5256,44 @@ module Tables = struct let _1 = # 260 "" ( List.flatten xss ) -# 5945 "src/ocaml/preprocess/parser_raw.ml" +# 5260 "src/ocaml/preprocess/parser_raw.ml" in -# 2059 "src/ocaml/preprocess/parser_raw.mly" +# 2134 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 5950 "src/ocaml/preprocess/parser_raw.ml" +# 5265 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 984 "src/ocaml/preprocess/parser_raw.mly" +# 1021 "src/ocaml/preprocess/parser_raw.mly" ( extra_cstr _startpos _endpos _1 ) -# 5959 "src/ocaml/preprocess/parser_raw.ml" +# 5274 "src/ocaml/preprocess/parser_raw.ml" in -# 2046 "src/ocaml/preprocess/parser_raw.mly" +# 2121 "src/ocaml/preprocess/parser_raw.mly" ( Cstr.mk _1 _2 ) -# 5965 "src/ocaml/preprocess/parser_raw.ml" +# 5280 "src/ocaml/preprocess/parser_raw.ml" in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 5973 "src/ocaml/preprocess/parser_raw.ml" +# 5288 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2034 "src/ocaml/preprocess/parser_raw.mly" +# 2109 "src/ocaml/preprocess/parser_raw.mly" ( mkclass ~loc:_sloc ~attrs:_2 (Pcl_structure _3) ) -# 5982 "src/ocaml/preprocess/parser_raw.ml" +# 5297 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6001,9 +5316,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.class_type) = -# 2137 "src/ocaml/preprocess/parser_raw.mly" +# 2212 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 6007 "src/ocaml/preprocess/parser_raw.ml" +# 5322 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6049,14 +5364,14 @@ module Tables = struct let _v : (Parsetree.class_type) = let _1 = let _1 = let label = -# 3519 "src/ocaml/preprocess/parser_raw.mly" +# 3659 "src/ocaml/preprocess/parser_raw.mly" ( Optional label ) -# 6055 "src/ocaml/preprocess/parser_raw.ml" +# 5370 "src/ocaml/preprocess/parser_raw.ml" in -# 2143 "src/ocaml/preprocess/parser_raw.mly" +# 2218 "src/ocaml/preprocess/parser_raw.mly" ( Pcty_arrow(label, domain, codomain) ) -# 6060 "src/ocaml/preprocess/parser_raw.ml" +# 5375 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_label_) in @@ -6064,15 +5379,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1037 "src/ocaml/preprocess/parser_raw.mly" +# 1074 "src/ocaml/preprocess/parser_raw.mly" ( mkcty ~loc:_sloc _1 ) -# 6070 "src/ocaml/preprocess/parser_raw.ml" +# 5385 "src/ocaml/preprocess/parser_raw.ml" in -# 2144 "src/ocaml/preprocess/parser_raw.mly" +# 2219 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 6076 "src/ocaml/preprocess/parser_raw.ml" +# 5391 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6119,9 +5434,9 @@ module Tables = struct let domain : (Parsetree.core_type) = Obj.magic domain in let _2 : unit = Obj.magic _2 in let label : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 6125 "src/ocaml/preprocess/parser_raw.ml" +# 5440 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic label in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_label_ in @@ -6129,14 +5444,14 @@ module Tables = struct let _v : (Parsetree.class_type) = let _1 = let _1 = let label = -# 3521 "src/ocaml/preprocess/parser_raw.mly" +# 3661 "src/ocaml/preprocess/parser_raw.mly" ( Labelled label ) -# 6135 "src/ocaml/preprocess/parser_raw.ml" +# 5450 "src/ocaml/preprocess/parser_raw.ml" in -# 2143 "src/ocaml/preprocess/parser_raw.mly" +# 2218 "src/ocaml/preprocess/parser_raw.mly" ( Pcty_arrow(label, domain, codomain) ) -# 6140 "src/ocaml/preprocess/parser_raw.ml" +# 5455 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_label_) in @@ -6144,15 +5459,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1037 "src/ocaml/preprocess/parser_raw.mly" +# 1074 "src/ocaml/preprocess/parser_raw.mly" ( mkcty ~loc:_sloc _1 ) -# 6150 "src/ocaml/preprocess/parser_raw.ml" +# 5465 "src/ocaml/preprocess/parser_raw.ml" in -# 2144 "src/ocaml/preprocess/parser_raw.mly" +# 2219 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 6156 "src/ocaml/preprocess/parser_raw.ml" +# 5471 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6191,14 +5506,14 @@ module Tables = struct let _v : (Parsetree.class_type) = let _1 = let _1 = let label = -# 3523 "src/ocaml/preprocess/parser_raw.mly" +# 3663 "src/ocaml/preprocess/parser_raw.mly" ( Nolabel ) -# 6197 "src/ocaml/preprocess/parser_raw.ml" +# 5512 "src/ocaml/preprocess/parser_raw.ml" in -# 2143 "src/ocaml/preprocess/parser_raw.mly" +# 2218 "src/ocaml/preprocess/parser_raw.mly" ( Pcty_arrow(label, domain, codomain) ) -# 6202 "src/ocaml/preprocess/parser_raw.ml" +# 5517 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_domain_) in @@ -6206,15 +5521,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1037 "src/ocaml/preprocess/parser_raw.mly" +# 1074 "src/ocaml/preprocess/parser_raw.mly" ( mkcty ~loc:_sloc _1 ) -# 6212 "src/ocaml/preprocess/parser_raw.ml" +# 5527 "src/ocaml/preprocess/parser_raw.ml" in -# 2144 "src/ocaml/preprocess/parser_raw.mly" +# 2219 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 6218 "src/ocaml/preprocess/parser_raw.ml" +# 5533 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6297,9 +5612,9 @@ module Tables = struct let csig : (Parsetree.class_type) = Obj.magic csig in let _8 : unit = Obj.magic _8 in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 6303 "src/ocaml/preprocess/parser_raw.ml" +# 5618 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in let virt : (Asttypes.virtual_flag) = Obj.magic virt in @@ -6315,9 +5630,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 6321 "src/ocaml/preprocess/parser_raw.ml" +# 5636 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -6327,24 +5642,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 6333 "src/ocaml/preprocess/parser_raw.ml" +# 5648 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 6341 "src/ocaml/preprocess/parser_raw.ml" +# 5656 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2284 "src/ocaml/preprocess/parser_raw.mly" +# 2359 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in @@ -6352,19 +5667,19 @@ module Tables = struct ext, Ci.mk id csig ~virt ~params ~attrs ~loc ~docs ) -# 6356 "src/ocaml/preprocess/parser_raw.ml" +# 5671 "src/ocaml/preprocess/parser_raw.ml" in -# 1221 "src/ocaml/preprocess/parser_raw.mly" +# 1279 "src/ocaml/preprocess/parser_raw.mly" ( let (x, b) = a in x, b :: bs ) -# 6362 "src/ocaml/preprocess/parser_raw.ml" +# 5677 "src/ocaml/preprocess/parser_raw.ml" in -# 2272 "src/ocaml/preprocess/parser_raw.mly" +# 2347 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 6368 "src/ocaml/preprocess/parser_raw.ml" +# 5683 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6387,9 +5702,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3812 "src/ocaml/preprocess/parser_raw.mly" +# 4008 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 6393 "src/ocaml/preprocess/parser_raw.ml" +# 5708 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6408,17 +5723,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 779 "src/ocaml/preprocess/parser_raw.mly" +# 824 "src/ocaml/preprocess/parser_raw.mly" (string * char option) -# 6414 "src/ocaml/preprocess/parser_raw.ml" +# 5729 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.constant) = -# 3691 "src/ocaml/preprocess/parser_raw.mly" +# 3887 "src/ocaml/preprocess/parser_raw.mly" ( let (n, m) = _1 in Pconst_integer (n, m) ) -# 6422 "src/ocaml/preprocess/parser_raw.ml" +# 5737 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6437,17 +5752,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 738 "src/ocaml/preprocess/parser_raw.mly" +# 783 "src/ocaml/preprocess/parser_raw.mly" (char) -# 6443 "src/ocaml/preprocess/parser_raw.ml" +# 5758 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.constant) = -# 3692 "src/ocaml/preprocess/parser_raw.mly" +# 3888 "src/ocaml/preprocess/parser_raw.mly" ( Pconst_char _1 ) -# 6451 "src/ocaml/preprocess/parser_raw.ml" +# 5766 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6466,17 +5781,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 831 "src/ocaml/preprocess/parser_raw.mly" +# 876 "src/ocaml/preprocess/parser_raw.mly" (string * Location.t * string option) -# 6472 "src/ocaml/preprocess/parser_raw.ml" +# 5787 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.constant) = -# 3693 "src/ocaml/preprocess/parser_raw.mly" +# 3889 "src/ocaml/preprocess/parser_raw.mly" ( let (s, strloc, d) = _1 in Pconst_string (s, strloc, d) ) -# 6480 "src/ocaml/preprocess/parser_raw.ml" +# 5795 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6495,17 +5810,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 758 "src/ocaml/preprocess/parser_raw.mly" +# 803 "src/ocaml/preprocess/parser_raw.mly" (string * char option) -# 6501 "src/ocaml/preprocess/parser_raw.ml" +# 5816 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.constant) = -# 3694 "src/ocaml/preprocess/parser_raw.mly" +# 3890 "src/ocaml/preprocess/parser_raw.mly" ( let (f, m) = _1 in Pconst_float (f, m) ) -# 6509 "src/ocaml/preprocess/parser_raw.ml" +# 5824 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6535,9 +5850,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (string) = -# 3767 "src/ocaml/preprocess/parser_raw.mly" +# 3963 "src/ocaml/preprocess/parser_raw.mly" ( "[]" ) -# 6541 "src/ocaml/preprocess/parser_raw.ml" +# 5856 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6567,9 +5882,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (string) = -# 3768 "src/ocaml/preprocess/parser_raw.mly" +# 3964 "src/ocaml/preprocess/parser_raw.mly" ( "()" ) -# 6573 "src/ocaml/preprocess/parser_raw.ml" +# 5888 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6592,9 +5907,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3769 "src/ocaml/preprocess/parser_raw.mly" +# 3965 "src/ocaml/preprocess/parser_raw.mly" ( "false" ) -# 6598 "src/ocaml/preprocess/parser_raw.ml" +# 5913 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6617,9 +5932,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3770 "src/ocaml/preprocess/parser_raw.mly" +# 3966 "src/ocaml/preprocess/parser_raw.mly" ( "true" ) -# 6623 "src/ocaml/preprocess/parser_raw.ml" +# 5938 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6638,17 +5953,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 845 "src/ocaml/preprocess/parser_raw.mly" +# 890 "src/ocaml/preprocess/parser_raw.mly" (string) -# 6644 "src/ocaml/preprocess/parser_raw.ml" +# 5959 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3773 "src/ocaml/preprocess/parser_raw.mly" +# 3969 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 6652 "src/ocaml/preprocess/parser_raw.ml" +# 5967 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6685,14 +6000,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (string) = let _1 = -# 3764 "src/ocaml/preprocess/parser_raw.mly" +# 3960 "src/ocaml/preprocess/parser_raw.mly" ( "::" ) -# 6691 "src/ocaml/preprocess/parser_raw.ml" +# 6006 "src/ocaml/preprocess/parser_raw.ml" in -# 3774 "src/ocaml/preprocess/parser_raw.mly" +# 3970 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 6696 "src/ocaml/preprocess/parser_raw.ml" +# 6011 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6715,9 +6030,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3775 "src/ocaml/preprocess/parser_raw.mly" +# 3971 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 6721 "src/ocaml/preprocess/parser_raw.ml" +# 6036 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6740,9 +6055,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3778 "src/ocaml/preprocess/parser_raw.mly" +# 3974 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 6746 "src/ocaml/preprocess/parser_raw.ml" +# 6061 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6795,15 +6110,15 @@ module Tables = struct let _v : (Longident.t) = let _3 = let (_2, _1) = (_2_inlined1, _1_inlined1) in -# 3764 "src/ocaml/preprocess/parser_raw.mly" +# 3960 "src/ocaml/preprocess/parser_raw.mly" ( "::" ) -# 6801 "src/ocaml/preprocess/parser_raw.ml" +# 6116 "src/ocaml/preprocess/parser_raw.ml" in -# 3779 "src/ocaml/preprocess/parser_raw.mly" +# 3975 "src/ocaml/preprocess/parser_raw.mly" ( Ldot(_1,_3) ) -# 6807 "src/ocaml/preprocess/parser_raw.ml" +# 6122 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6840,14 +6155,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Longident.t) = let _1 = -# 3764 "src/ocaml/preprocess/parser_raw.mly" +# 3960 "src/ocaml/preprocess/parser_raw.mly" ( "::" ) -# 6846 "src/ocaml/preprocess/parser_raw.ml" +# 6161 "src/ocaml/preprocess/parser_raw.ml" in -# 3780 "src/ocaml/preprocess/parser_raw.mly" +# 3976 "src/ocaml/preprocess/parser_raw.mly" ( Lident _1 ) -# 6851 "src/ocaml/preprocess/parser_raw.ml" +# 6166 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6870,9 +6185,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3781 "src/ocaml/preprocess/parser_raw.mly" +# 3977 "src/ocaml/preprocess/parser_raw.mly" ( Lident _1 ) -# 6876 "src/ocaml/preprocess/parser_raw.ml" +# 6191 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6909,9 +6224,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.core_type * Parsetree.core_type) = -# 2228 "src/ocaml/preprocess/parser_raw.mly" +# 2303 "src/ocaml/preprocess/parser_raw.mly" ( _1, _3 ) -# 6915 "src/ocaml/preprocess/parser_raw.ml" +# 6230 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6936,26 +6251,26 @@ module Tables = struct let _v : (Parsetree.constructor_arguments) = let tys = let xs = let xs = -# 1108 "src/ocaml/preprocess/parser_raw.mly" +# 1166 "src/ocaml/preprocess/parser_raw.mly" ( [ x ] ) -# 6942 "src/ocaml/preprocess/parser_raw.ml" +# 6257 "src/ocaml/preprocess/parser_raw.ml" in # 253 "" ( List.rev xs ) -# 6947 "src/ocaml/preprocess/parser_raw.ml" +# 6262 "src/ocaml/preprocess/parser_raw.ml" in -# 1128 "src/ocaml/preprocess/parser_raw.mly" +# 1186 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 6953 "src/ocaml/preprocess/parser_raw.ml" +# 6268 "src/ocaml/preprocess/parser_raw.ml" in -# 3322 "src/ocaml/preprocess/parser_raw.mly" +# 3462 "src/ocaml/preprocess/parser_raw.mly" ( Pcstr_tuple tys ) -# 6959 "src/ocaml/preprocess/parser_raw.ml" +# 6274 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -6994,26 +6309,26 @@ module Tables = struct let _v : (Parsetree.constructor_arguments) = let tys = let xs = let xs = -# 1112 "src/ocaml/preprocess/parser_raw.mly" +# 1170 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 7000 "src/ocaml/preprocess/parser_raw.ml" +# 6315 "src/ocaml/preprocess/parser_raw.ml" in # 253 "" ( List.rev xs ) -# 7005 "src/ocaml/preprocess/parser_raw.ml" +# 6320 "src/ocaml/preprocess/parser_raw.ml" in -# 1128 "src/ocaml/preprocess/parser_raw.mly" +# 1186 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 7011 "src/ocaml/preprocess/parser_raw.ml" +# 6326 "src/ocaml/preprocess/parser_raw.ml" in -# 3322 "src/ocaml/preprocess/parser_raw.mly" +# 3462 "src/ocaml/preprocess/parser_raw.mly" ( Pcstr_tuple tys ) -# 7017 "src/ocaml/preprocess/parser_raw.ml" +# 6332 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7050,9 +6365,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.constructor_arguments) = -# 3324 "src/ocaml/preprocess/parser_raw.mly" +# 3464 "src/ocaml/preprocess/parser_raw.mly" ( Pcstr_record _2 ) -# 7056 "src/ocaml/preprocess/parser_raw.ml" +# 6371 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7075,9 +6390,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.constructor_declaration list) = -# 3238 "src/ocaml/preprocess/parser_raw.mly" +# 3378 "src/ocaml/preprocess/parser_raw.mly" ( [] ) -# 7081 "src/ocaml/preprocess/parser_raw.ml" +# 6396 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7100,14 +6415,14 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_xs_ in let _v : (Parsetree.constructor_declaration list) = let cs = -# 1213 "src/ocaml/preprocess/parser_raw.mly" +# 1271 "src/ocaml/preprocess/parser_raw.mly" ( List.rev xs ) -# 7106 "src/ocaml/preprocess/parser_raw.ml" +# 6421 "src/ocaml/preprocess/parser_raw.ml" in -# 3240 "src/ocaml/preprocess/parser_raw.mly" +# 3380 "src/ocaml/preprocess/parser_raw.mly" ( cs ) -# 7111 "src/ocaml/preprocess/parser_raw.ml" +# 6426 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7130,14 +6445,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.core_type) = let _1 = -# 3481 "src/ocaml/preprocess/parser_raw.mly" +# 3621 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 7136 "src/ocaml/preprocess/parser_raw.ml" +# 6451 "src/ocaml/preprocess/parser_raw.ml" in -# 3471 "src/ocaml/preprocess/parser_raw.mly" +# 3611 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 7141 "src/ocaml/preprocess/parser_raw.ml" +# 6456 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7167,9 +6482,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.core_type) = -# 3473 "src/ocaml/preprocess/parser_raw.mly" +# 3613 "src/ocaml/preprocess/parser_raw.mly" ( Typ.attr _1 _2 ) -# 7173 "src/ocaml/preprocess/parser_raw.ml" +# 6488 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7187,14 +6502,14 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let _1 : unit = Obj.magic _1 in + let _1 : (Parsetree.core_type) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in - let _v : (Asttypes.direction_flag) = -# 3878 "src/ocaml/preprocess/parser_raw.mly" - ( Upto ) -# 7198 "src/ocaml/preprocess/parser_raw.ml" + let _v : (Parsetree.core_type) = +# 3761 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 6513 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7212,14 +6527,39 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let _1 : unit = Obj.magic _1 in + let _1 : (Parsetree.core_type) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in - let _v : (Asttypes.direction_flag) = -# 3879 "src/ocaml/preprocess/parser_raw.mly" - ( Downto ) -# 7223 "src/ocaml/preprocess/parser_raw.ml" + let _v : (Parsetree.core_type) = +# 3761 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 6538 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + } = _menhir_stack in + let _1 : (Parsetree.core_type) = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_ in + let _v : (Parsetree.core_type) = +# 3761 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 6563 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7237,9 +6577,9 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.semv = type_; + MenhirLib.EngineTypes.startp = _startpos_type__; + MenhirLib.EngineTypes.endp = _endpos_type__; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _menhir_s; MenhirLib.EngineTypes.semv = _1; @@ -7249,19 +6589,16 @@ module Tables = struct }; }; } = _menhir_stack in - let _3 : (Parsetree.expression) = Obj.magic _3 in - let _2 : unit = Obj.magic _2 in - let _1 : (Ast_helper.let_bindings) = Obj.magic _1 in + let _3 : unit = Obj.magic _3 in + let type_ : (Parsetree.core_type) = Obj.magic type_ in + let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in - let _v : (Parsetree.expression) = let _endpos = _endpos__3_ in - let _startpos = _startpos__1_ in - let _loc = (_startpos, _endpos) in - -# 4088 "src/ocaml/preprocess/parser_raw.mly" - ( expr_of_lwt_bindings ~loc:_loc _1 (merloc _endpos__2_ _3) ) -# 7265 "src/ocaml/preprocess/parser_raw.ml" + let _v : (Parsetree.core_type) = +# 3714 "src/ocaml/preprocess/parser_raw.mly" + ( type_ ) +# 6602 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7274,29 +6611,29 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = xs; - MenhirLib.EngineTypes.startp = _startpos_xs_; - MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _menhir_s; MenhirLib.EngineTypes.semv = _1; @@ -7309,60 +6646,51 @@ module Tables = struct }; }; } = _menhir_stack in - let xs : (Parsetree.case list) = Obj.magic xs in - let _4 : unit = Obj.magic _4 in - let _3 : (Parsetree.expression) = Obj.magic _3 in + let _5 : unit = Obj.magic _5 in + let _1_inlined3 : (Parsetree.module_type) = Obj.magic _1_inlined3 in let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos_xs_ in - let _v : (Parsetree.expression) = let _5 = - let xs = - let xs = -# 253 "" - ( List.rev xs ) -# 7327 "src/ocaml/preprocess/parser_raw.ml" - in - -# 1185 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 7332 "src/ocaml/preprocess/parser_raw.ml" - - in + let _endpos = _endpos__5_ in + let _v : (Parsetree.core_type) = let package_type = + let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2778 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 7338 "src/ocaml/preprocess/parser_raw.ml" +# 3807 "src/ocaml/preprocess/parser_raw.mly" + ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in + let descr = Ptyp_package (lid, cstrs) in + mktyp ~loc:_sloc ~attrs descr ) +# 6669 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__5_ = _endpos_xs_ in - let _2 = + let attrs = let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 7349 "src/ocaml/preprocess/parser_raw.ml" +# 6679 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 7355 "src/ocaml/preprocess/parser_raw.ml" +# 6685 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__5_ in - let _startpos = _startpos__1_ in - let _loc = (_startpos, _endpos) in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 4090 "src/ocaml/preprocess/parser_raw.mly" - ( let expr = mkexp_attrs ~loc:_loc - (Pexp_match(Fake.app Fake.Lwt.un_lwt _3, List.rev _5)) _2 in - Fake.app Fake.Lwt.in_lwt expr ) -# 7366 "src/ocaml/preprocess/parser_raw.ml" +# 3716 "src/ocaml/preprocess/parser_raw.mly" + ( wrap_typ_attrs ~loc:_sloc (reloc_typ ~loc:_sloc package_type) attrs ) +# 6694 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7380,54 +6708,44 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.semv = field; + MenhirLib.EngineTypes.startp = _startpos_field_; + MenhirLib.EngineTypes.endp = _endpos_field_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; }; } = _menhir_stack in - let _3 : (Parsetree.expression) = Obj.magic _3 in - let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _3 : unit = Obj.magic _3 in + let field : (Parsetree.row_field) = Obj.magic field in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in - let _v : (Parsetree.expression) = let _2 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 7416 "src/ocaml/preprocess/parser_raw.ml" - - in + let _v : (Parsetree.core_type) = let _1 = + let _1 = +# 3719 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_variant([ field ], Closed, None) ) +# 6734 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos__1_ = _endpos__3_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 7422 "src/ocaml/preprocess/parser_raw.ml" +# 1064 "src/ocaml/preprocess/parser_raw.mly" + ( mktyp ~loc:_sloc _1 ) +# 6743 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos = _endpos__3_ in - let _startpos = _startpos__1_ in - let _loc = (_startpos, _endpos) in -# 4094 "src/ocaml/preprocess/parser_raw.mly" - ( reloc_exp ~loc:_loc (Fake.app Fake.Lwt.in_lwt _3) ) -# 7431 "src/ocaml/preprocess/parser_raw.ml" +# 3736 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 6749 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7440,94 +6758,77 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = xs; - MenhirLib.EngineTypes.startp = _startpos_xs_; - MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; }; }; } = _menhir_stack in - let xs : (Parsetree.case list) = Obj.magic xs in let _4 : unit = Obj.magic _4 in - let _3 : (Parsetree.expression) = Obj.magic _3 in - let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let xs : (Parsetree.row_field list) = Obj.magic xs in + let _2 : unit = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos_xs_ in - let _v : (Parsetree.expression) = let _5 = - let xs = - let xs = + let _endpos = _endpos__4_ in + let _v : (Parsetree.core_type) = let _1 = + let _1 = + let fields = + let _1 = + let xs = # 253 "" ( List.rev xs ) -# 7493 "src/ocaml/preprocess/parser_raw.ml" - in - -# 1185 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 7498 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 2778 "src/ocaml/preprocess/parser_raw.mly" +# 6799 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1182 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 7504 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos__5_ = _endpos_xs_ in - let _2 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 6804 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3813 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 7515 "src/ocaml/preprocess/parser_raw.ml" +# 6810 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3721 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_variant(fields, Closed, None) ) +# 6816 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos__1_ = _endpos__4_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 7521 "src/ocaml/preprocess/parser_raw.ml" +# 1064 "src/ocaml/preprocess/parser_raw.mly" + ( mktyp ~loc:_sloc _1 ) +# 6826 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos = _endpos__5_ in - let _startpos = _startpos__1_ in - let _loc = (_startpos, _endpos) in -# 4096 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp_attrs ~loc:_loc - (Pexp_try(Fake.app Fake.Lwt.in_lwt _3, List.rev _5)) _2 ) -# 7531 "src/ocaml/preprocess/parser_raw.ml" +# 3736 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 6832 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7545,9 +6846,9 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _3; @@ -7555,55 +6856,69 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.semv = field; + MenhirLib.EngineTypes.startp = _startpos_field_; + MenhirLib.EngineTypes.endp = _endpos_field_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; }; }; }; } = _menhir_stack in - let _5 : (Parsetree.expression) = Obj.magic _5 in - let _4 : unit = Obj.magic _4 in - let _3 : (Parsetree.expression) = Obj.magic _3 in - let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _5 : unit = Obj.magic _5 in + let xs : (Parsetree.row_field list) = Obj.magic xs in + let _3 : unit = Obj.magic _3 in + let field : (Parsetree.row_field) = Obj.magic field in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in - let _v : (Parsetree.expression) = let _2 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" + let _v : (Parsetree.core_type) = let _1 = + let _1 = + let fields = + let _1 = + let xs = +# 253 "" + ( List.rev xs ) +# 6889 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1182 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 6894 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3813 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 7595 "src/ocaml/preprocess/parser_raw.ml" +# 6900 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3723 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_variant(field :: fields, Closed, None) ) +# 6906 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos__1_ = _endpos__5_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 7601 "src/ocaml/preprocess/parser_raw.ml" +# 1064 "src/ocaml/preprocess/parser_raw.mly" + ( mktyp ~loc:_sloc _1 ) +# 6916 "src/ocaml/preprocess/parser_raw.ml" in -# 4099 "src/ocaml/preprocess/parser_raw.mly" - ( Fake.app (Fake.app Fake.Lwt.finally_ _3) _5 ) -# 7607 "src/ocaml/preprocess/parser_raw.ml" +# 3736 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 6922 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7616,108 +6931,77 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _7; - MenhirLib.EngineTypes.startp = _startpos__7_; - MenhirLib.EngineTypes.endp = _endpos__7_; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _6; - MenhirLib.EngineTypes.startp = _startpos__6_; - MenhirLib.EngineTypes.endp = _endpos__6_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = xs; - MenhirLib.EngineTypes.startp = _startpos_xs_; - MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; }; }; } = _menhir_stack in - let _7 : (Parsetree.expression) = Obj.magic _7 in - let _6 : unit = Obj.magic _6 in - let xs : (Parsetree.case list) = Obj.magic xs in let _4 : unit = Obj.magic _4 in - let _3 : (Parsetree.expression) = Obj.magic _3 in - let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let xs : (Parsetree.row_field list) = Obj.magic xs in + let _2 : (unit option) = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__7_ in - let _v : (Parsetree.expression) = let _5 = - let xs = - let xs = -# 253 "" - ( List.rev xs ) -# 7683 "src/ocaml/preprocess/parser_raw.ml" - in - -# 1185 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 7688 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 2778 "src/ocaml/preprocess/parser_raw.mly" + let _endpos = _endpos__4_ in + let _v : (Parsetree.core_type) = let _1 = + let _1 = + let fields = + let _1 = + let xs = +# 253 "" + ( List.rev xs ) +# 6972 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1182 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 7694 "src/ocaml/preprocess/parser_raw.ml" - - in - let _2 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 6977 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3813 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 7704 "src/ocaml/preprocess/parser_raw.ml" +# 6983 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3725 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_variant(fields, Open, None) ) +# 6989 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos__1_ = _endpos__4_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 7710 "src/ocaml/preprocess/parser_raw.ml" +# 1064 "src/ocaml/preprocess/parser_raw.mly" + ( mktyp ~loc:_sloc _1 ) +# 6999 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos = _endpos__7_ in - let _startpos = _startpos__1_ in - let _loc = (_startpos, _endpos) in -# 4101 "src/ocaml/preprocess/parser_raw.mly" - ( let expr = mkexp_attrs ~loc:_loc - (Pexp_try (Fake.app Fake.Lwt.in_lwt _3, List.rev _5)) _2 in - Fake.app (Fake.app Fake.Lwt.finally_ expr) _7 ) -# 7721 "src/ocaml/preprocess/parser_raw.ml" +# 3736 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 7005 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7730,81 +7014,42 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _6; - MenhirLib.EngineTypes.startp = _startpos__6_; - MenhirLib.EngineTypes.endp = _endpos__6_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - }; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; } = _menhir_stack in - let _6 : unit = Obj.magic _6 in - let _5 : (Parsetree.expression) = Obj.magic _5 in - let _4 : unit = Obj.magic _4 in - let _3 : (Parsetree.expression) = Obj.magic _3 in - let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__6_ in - let _v : (Parsetree.expression) = let _2 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 7792 "src/ocaml/preprocess/parser_raw.ml" - - in + let _endpos = _endpos__2_ in + let _v : (Parsetree.core_type) = let _1 = + let _1 = +# 3727 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_variant([], Open, None) ) +# 7038 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos__1_ = _endpos__2_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 7798 "src/ocaml/preprocess/parser_raw.ml" +# 1064 "src/ocaml/preprocess/parser_raw.mly" + ( mktyp ~loc:_sloc _1 ) +# 7047 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos = _endpos__6_ in - let _startpos = _startpos__1_ in - let _loc = (_startpos, _endpos) in -# 4105 "src/ocaml/preprocess/parser_raw.mly" - ( let expr = Pexp_while (_3, Fake.(app Lwt.un_lwt _5)) in - Fake.(app Lwt.to_lwt (mkexp_attrs ~loc:_loc expr _2)) ) -# 7808 "src/ocaml/preprocess/parser_raw.ml" +# 3736 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 7053 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7817,109 +7062,77 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _10; - MenhirLib.EngineTypes.startp = _startpos__10_; - MenhirLib.EngineTypes.endp = _endpos__10_; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _9; - MenhirLib.EngineTypes.startp = _startpos__9_; - MenhirLib.EngineTypes.endp = _endpos__9_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _8; - MenhirLib.EngineTypes.startp = _startpos__8_; - MenhirLib.EngineTypes.endp = _endpos__8_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _7; - MenhirLib.EngineTypes.startp = _startpos__7_; - MenhirLib.EngineTypes.endp = _endpos__7_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _6; - MenhirLib.EngineTypes.startp = _startpos__6_; - MenhirLib.EngineTypes.endp = _endpos__6_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - }; - }; - }; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; }; }; } = _menhir_stack in - let _10 : unit = Obj.magic _10 in - let _9 : (Parsetree.expression) = Obj.magic _9 in - let _8 : unit = Obj.magic _8 in - let _7 : (Parsetree.expression) = Obj.magic _7 in - let _6 : (Asttypes.direction_flag) = Obj.magic _6 in - let _5 : (Parsetree.expression) = Obj.magic _5 in let _4 : unit = Obj.magic _4 in - let _3 : (Parsetree.pattern) = Obj.magic _3 in - let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let xs : (Parsetree.row_field list) = Obj.magic xs in + let _2 : (unit option) = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__10_ in - let _v : (Parsetree.expression) = let _2 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" + let _endpos = _endpos__4_ in + let _v : (Parsetree.core_type) = let _1 = + let _1 = + let fields = + let _1 = + let xs = +# 253 "" + ( List.rev xs ) +# 7103 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1182 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 7108 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3813 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 7907 "src/ocaml/preprocess/parser_raw.ml" +# 7114 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3729 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_variant(fields, Closed, Some []) ) +# 7120 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos__1_ = _endpos__4_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 7913 "src/ocaml/preprocess/parser_raw.ml" +# 1064 "src/ocaml/preprocess/parser_raw.mly" + ( mktyp ~loc:_sloc _1 ) +# 7130 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos = _endpos__10_ in - let _startpos = _startpos__1_ in - let _loc = (_startpos, _endpos) in -# 4108 "src/ocaml/preprocess/parser_raw.mly" - ( let expr = Pexp_for (_3, _5, _7, _6, Fake.(app Lwt.un_lwt _9)) in - Fake.(app Lwt.to_lwt (mkexp_attrs ~loc:_loc expr _2)) ) -# 7923 "src/ocaml/preprocess/parser_raw.ml" +# 3736 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 7136 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -7932,98 +7145,111 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _8; - MenhirLib.EngineTypes.startp = _startpos__8_; - MenhirLib.EngineTypes.endp = _endpos__8_; + MenhirLib.EngineTypes.semv = _6; + MenhirLib.EngineTypes.startp = _startpos__6_; + MenhirLib.EngineTypes.endp = _endpos__6_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _7; - MenhirLib.EngineTypes.startp = _startpos__7_; - MenhirLib.EngineTypes.endp = _endpos__7_; + MenhirLib.EngineTypes.semv = xs_inlined1; + MenhirLib.EngineTypes.startp = _startpos_xs_inlined1_; + MenhirLib.EngineTypes.endp = _endpos_xs_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _6; - MenhirLib.EngineTypes.startp = _startpos__6_; - MenhirLib.EngineTypes.endp = _endpos__6_; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; }; }; }; }; } = _menhir_stack in - let _8 : unit = Obj.magic _8 in - let _7 : (Parsetree.expression) = Obj.magic _7 in let _6 : unit = Obj.magic _6 in - let _5 : (Parsetree.expression) = Obj.magic _5 in + let xs_inlined1 : (string list) = Obj.magic xs_inlined1 in let _4 : unit = Obj.magic _4 in - let _3 : (Parsetree.pattern) = Obj.magic _3 in - let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let xs : (Parsetree.row_field list) = Obj.magic xs in + let _2 : (unit option) = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__8_ in - let _v : (Parsetree.expression) = let _2 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" + let _endpos = _endpos__6_ in + let _v : (Parsetree.core_type) = let _1 = + let _1 = + let tags = + let xs = xs_inlined1 in + let _1 = + let xs = +# 253 "" + ( List.rev xs ) +# 7201 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1129 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 7206 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3841 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 7212 "src/ocaml/preprocess/parser_raw.ml" + + in + let fields = + let _1 = + let xs = +# 253 "" + ( List.rev xs ) +# 7220 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1182 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 7225 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3813 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 8008 "src/ocaml/preprocess/parser_raw.ml" +# 7231 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3734 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_variant(fields, Closed, Some tags) ) +# 7237 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos__1_ = _endpos__6_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 8014 "src/ocaml/preprocess/parser_raw.ml" +# 1064 "src/ocaml/preprocess/parser_raw.mly" + ( mktyp ~loc:_sloc _1 ) +# 7247 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos = _endpos__8_ in - let _startpos = _startpos__1_ in - let _loc = (_startpos, _endpos) in -# 4111 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp_attrs ~loc:_loc - (Pexp_let (Nonrecursive, [Vb.mk _3 (Fake.(app Lwt.un_stream _5))], - Fake.(app Lwt.unit_lwt _7))) - _2 - ) -# 8027 "src/ocaml/preprocess/parser_raw.ml" +# 3736 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 7253 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8041,14 +7267,57 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let _1 : (Parsetree.expression) = Obj.magic _1 in + let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in - let _v : (Parsetree.expression) = -# 2395 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 8052 "src/ocaml/preprocess/parser_raw.ml" + let _v : (Asttypes.direction_flag) = +# 4074 "src/ocaml/preprocess/parser_raw.mly" + ( Upto ) +# 7278 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + } = _menhir_stack in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_ in + let _v : (Asttypes.direction_flag) = +# 4075 "src/ocaml/preprocess/parser_raw.mly" + ( Downto ) +# 7303 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let _menhir_s = _menhir_env.MenhirLib.EngineTypes.current in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in + let _endpos = _startpos in + let _v : (string Location.loc option) = +# 4230 "src/ocaml/preprocess/parser_raw.mly" + ( None ) +# 7321 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8061,107 +7330,26 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _7; - MenhirLib.EngineTypes.startp = _startpos__7_; - MenhirLib.EngineTypes.endp = _endpos__7_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _6; - MenhirLib.EngineTypes.startp = _startpos__6_; - MenhirLib.EngineTypes.endp = _endpos__6_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined3; - MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - }; - }; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; } = _menhir_stack in - let _7 : (Parsetree.expression) = Obj.magic _7 in - let _6 : unit = Obj.magic _6 in - let _5 : (Parsetree.module_expr) = Obj.magic _5 in - let _1_inlined3 : (string option) = Obj.magic _1_inlined3 in - let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in - let _2 : unit = Obj.magic _2 in + let _2 : (string Location.loc) = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__7_ in - let _v : (Parsetree.expression) = let _1 = - let _4 = - let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 990 "src/ocaml/preprocess/parser_raw.mly" - ( mkrhs _1 _sloc ) -# 8132 "src/ocaml/preprocess/parser_raw.ml" - - in - let _3 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 8142 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 8148 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 2430 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_letmodule(_4, _5, (merloc _endpos__6_ _7)), _3 ) -# 8154 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos__1_ = _endpos__7_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 2397 "src/ocaml/preprocess/parser_raw.mly" - ( let desc, attrs = _1 in - mkexp_attrs ~loc:_sloc desc attrs ) -# 8165 "src/ocaml/preprocess/parser_raw.ml" + let _endpos = _endpos__2_ in + let _v : (string Location.loc option) = +# 4231 "src/ocaml/preprocess/parser_raw.mly" + ( Some _2 ) +# 7353 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8174,135 +7362,40 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _6; - MenhirLib.EngineTypes.startp = _startpos__6_; - MenhirLib.EngineTypes.endp = _endpos__6_; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined4; - MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2_inlined1; - MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined3; - MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - }; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; }; }; } = _menhir_stack in - let _6 : (Parsetree.expression) = Obj.magic _6 in - let _5 : unit = Obj.magic _5 in - let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in - let _2_inlined1 : (Ocaml_parsing.Ast_helper.str list * Parsetree.constructor_arguments * - Parsetree.core_type option) = Obj.magic _2_inlined1 in - let _1_inlined3 : (string) = Obj.magic _1_inlined3 in - let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in - let _2 : unit = Obj.magic _2 in + let _4 : unit = Obj.magic _4 in + let _3 : (Parsetree.payload) = Obj.magic _3 in + let _2 : (string Location.loc) = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__6_ in - let _v : (Parsetree.expression) = let _1 = - let _4 = - let (_endpos__1_inlined1_, _endpos__1_, _startpos__1_, _1_inlined1, _2, _1) = (_endpos__1_inlined4_, _endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined4, _2_inlined1, _1_inlined3) in - let _3 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 8252 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos__3_ = _endpos__1_inlined1_ in - let _1 = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 990 "src/ocaml/preprocess/parser_raw.mly" - ( mkrhs _1 _sloc ) -# 8263 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 3302 "src/ocaml/preprocess/parser_raw.mly" - ( let vars, args, res = _2 in - Te.decl _1 ~vars ~args ?res ~attrs:_3 ~loc:(make_loc _sloc) ) -# 8273 "src/ocaml/preprocess/parser_raw.ml" - - in - let _3 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 8283 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 8289 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 2432 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_letexception(_4, _6), _3 ) -# 8295 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos__1_ = _endpos__6_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 2397 "src/ocaml/preprocess/parser_raw.mly" - ( let desc, attrs = _1 in - mkexp_attrs ~loc:_sloc desc attrs ) -# 8306 "src/ocaml/preprocess/parser_raw.ml" + let _endpos = _endpos__4_ in + let _v : (Parsetree.extension) = +# 4243 "src/ocaml/preprocess/parser_raw.mly" + ( (_2, _3) ) +# 7399 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8314,97 +7407,27 @@ module Tables = struct (fun _menhir_env -> let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _7; - MenhirLib.EngineTypes.startp = _startpos__7_; - MenhirLib.EngineTypes.endp = _endpos__7_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _6; - MenhirLib.EngineTypes.startp = _startpos__6_; - MenhirLib.EngineTypes.endp = _endpos__6_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - }; - }; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let _7 : (Parsetree.expression) = Obj.magic _7 in - let _6 : unit = Obj.magic _6 in - let _5 : (Parsetree.module_expr) = Obj.magic _5 in - let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in - let _2 : unit = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in + let _1 : ( +# 878 "src/ocaml/preprocess/parser_raw.mly" + (string * Location.t * string * Location.t * string option) +# 7420 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__7_ in - let _v : (Parsetree.expression) = let _1 = - let _4 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 8378 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 8384 "src/ocaml/preprocess/parser_raw.ml" - - in - let _3 = -# 3933 "src/ocaml/preprocess/parser_raw.mly" - ( Fresh ) -# 8390 "src/ocaml/preprocess/parser_raw.ml" - in - -# 2434 "src/ocaml/preprocess/parser_raw.mly" - ( let open_loc = make_loc (_startpos__2_, _endpos__5_) in - let od = Opn.mk _5 ~override:_3 ~loc:open_loc in - Pexp_open(od, (merloc _endpos__6_ _7)), _4 ) -# 8397 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos__1_ = _endpos__7_ in let _endpos = _endpos__1_ in + let _v : (Parsetree.extension) = let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2397 "src/ocaml/preprocess/parser_raw.mly" - ( let desc, attrs = _1 in - mkexp_attrs ~loc:_sloc desc attrs ) -# 8408 "src/ocaml/preprocess/parser_raw.ml" +# 4245 "src/ocaml/preprocess/parser_raw.mly" + ( mk_quotedext ~loc:_sloc _1 ) +# 7431 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8417,106 +7440,82 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _7; - MenhirLib.EngineTypes.startp = _startpos__7_; - MenhirLib.EngineTypes.endp = _endpos__7_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _6; - MenhirLib.EngineTypes.startp = _startpos__6_; - MenhirLib.EngineTypes.endp = _endpos__6_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined3; - MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; }; }; }; } = _menhir_stack in - let _7 : (Parsetree.expression) = Obj.magic _7 in - let _6 : unit = Obj.magic _6 in - let _5 : (Parsetree.module_expr) = Obj.magic _5 in let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in - let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in - let _1_inlined1 : unit = Obj.magic _1_inlined1 in - let _2 : unit = Obj.magic _2 in + let _1_inlined2 : (Longident.t) = Obj.magic _1_inlined2 in + let _3 : unit = Obj.magic _3 in + let _1_inlined1 : (string) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__7_ in - let _v : (Parsetree.expression) = let _1 = - let _4 = - let (_1_inlined1, _1) = (_1_inlined3, _1_inlined2) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" + let _endpos = _endpos__1_inlined3_ in + let _v : (Parsetree.extension_constructor) = let attrs = + let _1 = _1_inlined3 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 8487 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 8493 "src/ocaml/preprocess/parser_raw.ml" - - in - let _3 = - let _1 = _1_inlined1 in - -# 3934 "src/ocaml/preprocess/parser_raw.mly" - ( Override ) -# 8501 "src/ocaml/preprocess/parser_raw.ml" - - in +# 7486 "src/ocaml/preprocess/parser_raw.ml" -# 2434 "src/ocaml/preprocess/parser_raw.mly" - ( let open_loc = make_loc (_startpos__2_, _endpos__5_) in - let od = Opn.mk _5 ~override:_3 ~loc:open_loc in - Pexp_open(od, (merloc _endpos__6_ _7)), _4 ) -# 8509 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos_attrs_ = _endpos__1_inlined3_ in + let lid = + let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1027 "src/ocaml/preprocess/parser_raw.mly" + ( mkrhs _1 _sloc ) +# 7498 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos__7_ in - let _endpos = _endpos__1_ in + let cid = + let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1027 "src/ocaml/preprocess/parser_raw.mly" + ( mkrhs _1 _sloc ) +# 7509 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos_attrs_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2397 "src/ocaml/preprocess/parser_raw.mly" - ( let desc, attrs = _1 in - mkexp_attrs ~loc:_sloc desc attrs ) -# 8520 "src/ocaml/preprocess/parser_raw.ml" +# 3531 "src/ocaml/preprocess/parser_raw.mly" + ( let info = symbol_info _endpos in + Te.rebind cid lid ~attrs ~loc:(make_loc _sloc) ~info ) +# 7519 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8529,19 +7528,19 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = xs; - MenhirLib.EngineTypes.startp = _startpos_xs_; - MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _menhir_s; MenhirLib.EngineTypes.semv = _1; @@ -8552,64 +7551,98 @@ module Tables = struct }; }; } = _menhir_stack in - let xs : (Parsetree.case list) = Obj.magic xs in let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in - let _1 : unit = Obj.magic _1 in + let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in + let _3 : unit = Obj.magic _3 in + let _1 : (string) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos_xs_ in - let _v : (Parsetree.expression) = let _1 = - let _3 = - let xs = - let xs = -# 253 "" - ( List.rev xs ) -# 8569 "src/ocaml/preprocess/parser_raw.ml" - in - -# 1185 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 8574 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 2778 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 8580 "src/ocaml/preprocess/parser_raw.ml" - - in - let _2 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" + let _endpos = _endpos__1_inlined2_ in + let _v : (Parsetree.extension_constructor) = let attrs = + let _1 = _1_inlined2 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 8590 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 8596 "src/ocaml/preprocess/parser_raw.ml" - - in +# 7567 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos_attrs_ = _endpos__1_inlined2_ in + let lid = + let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2438 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_function _3, _2 ) -# 8602 "src/ocaml/preprocess/parser_raw.ml" +# 1027 "src/ocaml/preprocess/parser_raw.mly" + ( mkrhs _1 _sloc ) +# 7579 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos_xs_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in + let cid = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1027 "src/ocaml/preprocess/parser_raw.mly" + ( mkrhs _1 _sloc ) +# 7589 "src/ocaml/preprocess/parser_raw.ml" + + in + let _startpos_cid_ = _startpos__1_ in + let _1 = +# 4048 "src/ocaml/preprocess/parser_raw.mly" + ( () ) +# 7596 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos_attrs_ in + let _symbolstartpos = _startpos_cid_ in let _sloc = (_symbolstartpos, _endpos) in -# 2397 "src/ocaml/preprocess/parser_raw.mly" - ( let desc, attrs = _1 in - mkexp_attrs ~loc:_sloc desc attrs ) -# 8613 "src/ocaml/preprocess/parser_raw.ml" +# 3531 "src/ocaml/preprocess/parser_raw.mly" + ( let info = symbol_info _endpos in + Te.rebind cid lid ~attrs ~loc:(make_loc _sloc) ~info ) +# 7605 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = ext; + MenhirLib.EngineTypes.startp = _startpos_ext_; + MenhirLib.EngineTypes.endp = _endpos_ext_; + MenhirLib.EngineTypes.next = _menhir_stack; + } = _menhir_stack in + let ext : (Parsetree.extension) = Obj.magic ext in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_ext_ in + let _endpos = _endpos_ext_ in + let _v : (Parsetree.core_type) = let _1 = + let _1 = +# 3752 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_extension ext ) +# 7631 "src/ocaml/preprocess/parser_raw.ml" + in + let (_endpos__1_, _startpos__1_) = (_endpos_ext_, _startpos_ext_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1064 "src/ocaml/preprocess/parser_raw.mly" + ( mktyp ~loc:_sloc _1 ) +# 7640 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3754 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 7646 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8632,66 +7665,57 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; }; }; } = _menhir_stack in - let _4 : (Parsetree.expression) = Obj.magic _4 in - let _3 : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = Obj.magic _3 in - let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _4 : unit = Obj.magic _4 in + let _3 : (Parsetree.payload) = Obj.magic _3 in + let _2 : (string Location.loc) = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in - let _v : (Parsetree.expression) = let _1 = - let _2 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 8671 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 8677 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 2440 "src/ocaml/preprocess/parser_raw.mly" - ( let (l,o,p) = _3 in - Pexp_fun(l, o, p, _4), _2 ) -# 8684 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos__1_ = _endpos__4_ in - let _endpos = _endpos__1_ in + let _v : (Parsetree.attribute) = let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2397 "src/ocaml/preprocess/parser_raw.mly" - ( let desc, attrs = _1 in - mkexp_attrs ~loc:_sloc desc attrs ) -# 8695 "src/ocaml/preprocess/parser_raw.ml" +# 4218 "src/ocaml/preprocess/parser_raw.mly" + ( mark_symbol_docs _sloc; + mk_attr ~loc:(make_loc _sloc) _2 _3 ) +# 7696 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let _menhir_s = _menhir_env.MenhirLib.EngineTypes.current in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in + let _endpos = _startpos in + let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = let params = +# 2243 "src/ocaml/preprocess/parser_raw.mly" + ( [] ) +# 7714 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2060 "src/ocaml/preprocess/parser_raw.mly" + ( params ) +# 7719 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8704,104 +7728,52 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _7; - MenhirLib.EngineTypes.startp = _startpos__7_; - MenhirLib.EngineTypes.endp = _endpos__7_; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _6; - MenhirLib.EngineTypes.startp = _startpos__6_; - MenhirLib.EngineTypes.endp = _endpos__6_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = xs; - MenhirLib.EngineTypes.startp = _startpos_xs_; - MenhirLib.EngineTypes.endp = _endpos_xs_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - }; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; }; } = _menhir_stack in - let _7 : (Parsetree.expression) = Obj.magic _7 in - let _6 : unit = Obj.magic _6 in - let xs : (string Location.loc list) = Obj.magic xs in - let _4 : unit = Obj.magic _4 in let _3 : unit = Obj.magic _3 in - let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let xs : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic xs in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__7_ in - let _v : (Parsetree.expression) = let _1 = - let _5 = -# 2662 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 8770 "src/ocaml/preprocess/parser_raw.ml" - in - let _2 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 8779 "src/ocaml/preprocess/parser_raw.ml" - - in + let _endpos = _endpos__3_ in + let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = let params = + let params = + let xs = +# 253 "" + ( List.rev xs ) +# 7760 "src/ocaml/preprocess/parser_raw.ml" + in -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 8785 "src/ocaml/preprocess/parser_raw.ml" +# 1182 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 7765 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos = _endpos__7_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in -# 2443 "src/ocaml/preprocess/parser_raw.mly" - ( (mk_newtypes ~loc:_sloc _5 _7).pexp_desc, _2 ) -# 8794 "src/ocaml/preprocess/parser_raw.ml" +# 2245 "src/ocaml/preprocess/parser_raw.mly" + ( params ) +# 7771 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos__7_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in -# 2397 "src/ocaml/preprocess/parser_raw.mly" - ( let desc, attrs = _1 in - mkexp_attrs ~loc:_sloc desc attrs ) -# 8805 "src/ocaml/preprocess/parser_raw.ml" +# 2060 "src/ocaml/preprocess/parser_raw.mly" + ( params ) +# 7777 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8819,96 +7791,132 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; }; }; } = _menhir_stack in let xs : (Parsetree.case list) = Obj.magic xs in - let _4 : unit = Obj.magic _4 in - let _3 : (Parsetree.expression) = Obj.magic _3 in let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos_xs_ in - let _v : (Parsetree.expression) = let _1 = - let _5 = - let xs = - let xs = + let _v : (Parsetree.function_body) = let _3 = + let xs = + let xs = # 253 "" ( List.rev xs ) -# 8868 "src/ocaml/preprocess/parser_raw.ml" - in - -# 1185 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 8873 "src/ocaml/preprocess/parser_raw.ml" - - in +# 7825 "src/ocaml/preprocess/parser_raw.ml" + in -# 2778 "src/ocaml/preprocess/parser_raw.mly" +# 1243 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 8879 "src/ocaml/preprocess/parser_raw.ml" +# 7830 "src/ocaml/preprocess/parser_raw.ml" in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 7836 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in let _2 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 8889 "src/ocaml/preprocess/parser_raw.ml" - - in + let _1 = _1_inlined1 in -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 8895 "src/ocaml/preprocess/parser_raw.ml" +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 7847 "src/ocaml/preprocess/parser_raw.ml" in -# 2445 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_match(_3, _5), _2 ) -# 8901 "src/ocaml/preprocess/parser_raw.ml" +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 7853 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos_xs_ in - let _endpos = _endpos__1_ in + let _endpos = _endpos__3_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2397 "src/ocaml/preprocess/parser_raw.mly" - ( let desc, attrs = _1 in - mkexp_attrs ~loc:_sloc desc attrs ) -# 8912 "src/ocaml/preprocess/parser_raw.ml" +# 2879 "src/ocaml/preprocess/parser_raw.mly" + ( let ext, attrs = _2 in + match ext with + | None -> Pfunction_cases (_3, make_loc _sloc, attrs) + | Some _ -> + (* function%foo extension nodes interrupt the arity *) + let cases = Pfunction_cases (_3, make_loc _sloc, []) in + Pfunction_body + (mkexp_attrs ~loc:_sloc (mkfunction [] None cases) _2) + ) +# 7870 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + } = _menhir_stack in + let _1 : (Parsetree.expression) = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_ in + let _v : (Parsetree.function_body) = +# 2889 "src/ocaml/preprocess/parser_raw.mly" + ( Pfunction_body _1 ) +# 7895 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + } = _menhir_stack in + let _1 : (Parsetree.expression) = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_ in + let _v : (Parsetree.expression) = +# 2501 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 7920 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -8921,101 +7929,107 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = xs; - MenhirLib.EngineTypes.startp = _startpos_xs_; - MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.semv = _7; + MenhirLib.EngineTypes.startp = _startpos__7_; + MenhirLib.EngineTypes.endp = _endpos__7_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.semv = _6; + MenhirLib.EngineTypes.startp = _startpos__6_; + MenhirLib.EngineTypes.endp = _endpos__6_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; }; }; }; }; }; } = _menhir_stack in - let xs : (Parsetree.case list) = Obj.magic xs in - let _4 : unit = Obj.magic _4 in - let _3 : (Parsetree.expression) = Obj.magic _3 in + let _7 : (Parsetree.expression) = Obj.magic _7 in + let _6 : unit = Obj.magic _6 in + let _5 : (Parsetree.module_expr) = Obj.magic _5 in + let _1_inlined3 : (string option) = Obj.magic _1_inlined3 in let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos_xs_ in + let _endpos = _endpos__7_ in let _v : (Parsetree.expression) = let _1 = - let _5 = - let xs = - let xs = -# 253 "" - ( List.rev xs ) -# 8975 "src/ocaml/preprocess/parser_raw.ml" - in - -# 1185 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 8980 "src/ocaml/preprocess/parser_raw.ml" - - in + let _4 = + let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2778 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 8986 "src/ocaml/preprocess/parser_raw.ml" +# 1027 "src/ocaml/preprocess/parser_raw.mly" + ( mkrhs _1 _sloc ) +# 8000 "src/ocaml/preprocess/parser_raw.ml" in - let _2 = + let _3 = let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 8996 "src/ocaml/preprocess/parser_raw.ml" +# 8010 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 9002 "src/ocaml/preprocess/parser_raw.ml" +# 8016 "src/ocaml/preprocess/parser_raw.ml" in -# 2447 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_try(_3, _5), _2 ) -# 9008 "src/ocaml/preprocess/parser_raw.ml" +# 2539 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_letmodule(_4, _5, (merloc _endpos__6_ _7)), _3 ) +# 8022 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos_xs_ in + let _endpos__1_ = _endpos__7_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2397 "src/ocaml/preprocess/parser_raw.mly" +# 2503 "src/ocaml/preprocess/parser_raw.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 9019 "src/ocaml/preprocess/parser_raw.ml" +# 8033 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9028,29 +8042,29 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _7; - MenhirLib.EngineTypes.startp = _startpos__7_; - MenhirLib.EngineTypes.endp = _endpos__7_; + MenhirLib.EngineTypes.semv = _6; + MenhirLib.EngineTypes.startp = _startpos__6_; + MenhirLib.EngineTypes.endp = _endpos__6_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _6; - MenhirLib.EngineTypes.startp = _startpos__6_; - MenhirLib.EngineTypes.endp = _endpos__6_; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.semv = _1_inlined4; + MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.semv = _2_inlined1; + MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _1_inlined2; @@ -9062,11 +8076,17 @@ module Tables = struct MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; }; }; }; @@ -9075,49 +8095,82 @@ module Tables = struct }; }; } = _menhir_stack in - let _7 : (Parsetree.expression) = Obj.magic _7 in - let _6 : unit = Obj.magic _6 in - let _5 : (Parsetree.expression) = Obj.magic _5 in - let _4 : unit = Obj.magic _4 in - let _3 : (Parsetree.expression) = Obj.magic _3 in + let _6 : (Parsetree.expression) = Obj.magic _6 in + let _5 : unit = Obj.magic _5 in + let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in + let _2_inlined1 : (Ocaml_parsing.Ast_helper.str list * Parsetree.constructor_arguments * + Parsetree.core_type option) = Obj.magic _2_inlined1 in + let _1_inlined3 : (string) = Obj.magic _1_inlined3 in let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__7_ in + let _endpos = _endpos__6_ in let _v : (Parsetree.expression) = let _1 = - let _2 = + let _4 = + let (_endpos__1_inlined1_, _endpos__1_, _startpos__1_, _1_inlined1, _2, _1) = (_endpos__1_inlined4_, _endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined4, _2_inlined1, _1_inlined3) in + let _3 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 8120 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos__1_inlined1_ in + let _1 = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1027 "src/ocaml/preprocess/parser_raw.mly" + ( mkrhs _1 _sloc ) +# 8131 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 3442 "src/ocaml/preprocess/parser_raw.mly" + ( let vars, args, res = _2 in + Te.decl _1 ~vars ~args ?res ~attrs:_3 ~loc:(make_loc _sloc) ) +# 8141 "src/ocaml/preprocess/parser_raw.ml" + + in + let _3 = let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 9098 "src/ocaml/preprocess/parser_raw.ml" +# 8151 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 9104 "src/ocaml/preprocess/parser_raw.ml" +# 8157 "src/ocaml/preprocess/parser_raw.ml" in -# 2453 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_ifthenelse(_3, (merloc _endpos__4_ _5), Some (merloc _endpos__6_ _7)), _2 ) -# 9110 "src/ocaml/preprocess/parser_raw.ml" +# 2541 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_letexception(_4, _6), _3 ) +# 8163 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos__7_ in + let _endpos__1_ = _endpos__6_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2397 "src/ocaml/preprocess/parser_raw.mly" +# 2503 "src/ocaml/preprocess/parser_raw.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 9121 "src/ocaml/preprocess/parser_raw.ml" +# 8174 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9130,19 +8183,19 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.semv = _7; + MenhirLib.EngineTypes.startp = _startpos__7_; + MenhirLib.EngineTypes.endp = _endpos__7_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.semv = _6; + MenhirLib.EngineTypes.startp = _startpos__6_; + MenhirLib.EngineTypes.endp = _endpos__6_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _1_inlined2; @@ -9154,58 +8207,72 @@ module Tables = struct MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; }; }; }; }; }; } = _menhir_stack in - let _5 : (Parsetree.expression) = Obj.magic _5 in - let _4 : unit = Obj.magic _4 in - let _3 : (Parsetree.expression) = Obj.magic _3 in + let _7 : (Parsetree.expression) = Obj.magic _7 in + let _6 : unit = Obj.magic _6 in + let _5 : (Parsetree.module_expr) = Obj.magic _5 in let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__5_ in + let _endpos = _endpos__7_ in let _v : (Parsetree.expression) = let _1 = - let _2 = + let _4 = let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 9186 "src/ocaml/preprocess/parser_raw.ml" +# 8246 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 9192 "src/ocaml/preprocess/parser_raw.ml" +# 8252 "src/ocaml/preprocess/parser_raw.ml" in + let _3 = +# 4129 "src/ocaml/preprocess/parser_raw.mly" + ( Fresh ) +# 8258 "src/ocaml/preprocess/parser_raw.ml" + in -# 2455 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_ifthenelse(_3, (merloc _endpos__4_ _5), None), _2 ) -# 9198 "src/ocaml/preprocess/parser_raw.ml" +# 2543 "src/ocaml/preprocess/parser_raw.mly" + ( let open_loc = make_loc (_startpos__2_, _endpos__5_) in + let od = Opn.mk _5 ~override:_3 ~loc:open_loc in + Pexp_open(od, (merloc _endpos__6_ _7)), _4 ) +# 8265 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos__5_ in + let _endpos__1_ = _endpos__7_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2397 "src/ocaml/preprocess/parser_raw.mly" +# 2503 "src/ocaml/preprocess/parser_raw.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 9209 "src/ocaml/preprocess/parser_raw.ml" +# 8276 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9218,24 +8285,24 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _6; - MenhirLib.EngineTypes.startp = _startpos__6_; - MenhirLib.EngineTypes.endp = _endpos__6_; + MenhirLib.EngineTypes.semv = _7; + MenhirLib.EngineTypes.startp = _startpos__7_; + MenhirLib.EngineTypes.endp = _endpos__7_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.semv = _6; + MenhirLib.EngineTypes.startp = _startpos__6_; + MenhirLib.EngineTypes.endp = _endpos__6_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _1_inlined2; @@ -9247,11 +8314,17 @@ module Tables = struct MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; }; }; }; @@ -9259,48 +8332,59 @@ module Tables = struct }; }; } = _menhir_stack in + let _7 : (Parsetree.expression) = Obj.magic _7 in let _6 : unit = Obj.magic _6 in - let _5 : (Parsetree.expression) = Obj.magic _5 in - let _4 : unit = Obj.magic _4 in - let _3 : (Parsetree.expression) = Obj.magic _3 in - let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _5 : (Parsetree.module_expr) = Obj.magic _5 in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__6_ in + let _endpos = _endpos__7_ in let _v : (Parsetree.expression) = let _1 = - let _2 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _4 = + let (_1_inlined1, _1) = (_1_inlined3, _1_inlined2) in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 9281 "src/ocaml/preprocess/parser_raw.ml" +# 8355 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 9287 "src/ocaml/preprocess/parser_raw.ml" +# 8361 "src/ocaml/preprocess/parser_raw.ml" + + in + let _3 = + let _1 = _1_inlined1 in + +# 4130 "src/ocaml/preprocess/parser_raw.mly" + ( Override ) +# 8369 "src/ocaml/preprocess/parser_raw.ml" in -# 2457 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_while(_3, (merloc _endpos__4_ _5)), _2 ) -# 9293 "src/ocaml/preprocess/parser_raw.ml" - +# 2543 "src/ocaml/preprocess/parser_raw.mly" + ( let open_loc = make_loc (_startpos__2_, _endpos__5_) in + let od = Opn.mk _5 ~override:_3 ~loc:open_loc in + Pexp_open(od, (merloc _endpos__6_ _7)), _4 ) +# 8377 "src/ocaml/preprocess/parser_raw.ml" + in - let _endpos__1_ = _endpos__6_ in + let _endpos__1_ = _endpos__7_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2397 "src/ocaml/preprocess/parser_raw.mly" +# 2503 "src/ocaml/preprocess/parser_raw.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 9304 "src/ocaml/preprocess/parser_raw.ml" +# 8388 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9313,64 +8397,40 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _10; - MenhirLib.EngineTypes.startp = _startpos__10_; - MenhirLib.EngineTypes.endp = _endpos__10_; + MenhirLib.EngineTypes.semv = _6; + MenhirLib.EngineTypes.startp = _startpos__6_; + MenhirLib.EngineTypes.endp = _endpos__6_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _9; - MenhirLib.EngineTypes.startp = _startpos__9_; - MenhirLib.EngineTypes.endp = _endpos__9_; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _8; - MenhirLib.EngineTypes.startp = _startpos__8_; - MenhirLib.EngineTypes.endp = _endpos__8_; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _7; - MenhirLib.EngineTypes.startp = _startpos__7_; - MenhirLib.EngineTypes.endp = _endpos__7_; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _6; - MenhirLib.EngineTypes.startp = _startpos__6_; - MenhirLib.EngineTypes.endp = _endpos__6_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; }; }; @@ -9378,52 +8438,50 @@ module Tables = struct }; }; } = _menhir_stack in - let _10 : unit = Obj.magic _10 in - let _9 : (Parsetree.expression) = Obj.magic _9 in - let _8 : unit = Obj.magic _8 in - let _7 : (Parsetree.expression) = Obj.magic _7 in - let _6 : (Asttypes.direction_flag) = Obj.magic _6 in - let _5 : (Parsetree.expression) = Obj.magic _5 in - let _4 : unit = Obj.magic _4 in - let _3 : (Parsetree.pattern) = Obj.magic _3 in + let _6 : (Parsetree.function_body) = Obj.magic _6 in + let _5 : unit = Obj.magic _5 in + let _4 : (Parsetree.core_type option) = Obj.magic _4 in + let _3 : (Parsetree.function_param list) = Obj.magic _3 in let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__10_ in + let _endpos = _endpos__6_ in let _v : (Parsetree.expression) = let _1 = let _2 = let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 9404 "src/ocaml/preprocess/parser_raw.ml" +# 8460 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 9410 "src/ocaml/preprocess/parser_raw.ml" +# 8466 "src/ocaml/preprocess/parser_raw.ml" in -# 2460 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_for(_3, (merloc _endpos__4_ _5), (merloc _endpos__6_ _7), _6, (merloc _endpos__8_ _9)), _2 ) -# 9416 "src/ocaml/preprocess/parser_raw.ml" +# 2549 "src/ocaml/preprocess/parser_raw.mly" + ( let body_constraint = Option.map (fun x -> Pconstraint x) _4 in + mkfunction _3 body_constraint _6, _2 + ) +# 8474 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos__10_ in + let _endpos__1_ = _endpos__6_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2397 "src/ocaml/preprocess/parser_raw.mly" +# 2503 "src/ocaml/preprocess/parser_raw.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 9427 "src/ocaml/preprocess/parser_raw.ml" +# 8485 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9436,68 +8494,101 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; }; }; }; } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _4 : unit = Obj.magic _4 in let _3 : (Parsetree.expression) = Obj.magic _3 in let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__3_ in + let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = + let _5 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 8548 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 8553 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 8559 "src/ocaml/preprocess/parser_raw.ml" + + in let _2 = let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 9478 "src/ocaml/preprocess/parser_raw.ml" +# 8569 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 9484 "src/ocaml/preprocess/parser_raw.ml" +# 8575 "src/ocaml/preprocess/parser_raw.ml" in -# 2462 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_assert _3, _2 ) -# 9490 "src/ocaml/preprocess/parser_raw.ml" +# 2553 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_match(_3, _5), _2 ) +# 8581 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos__3_ in + let _endpos__1_ = _endpos_xs_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2397 "src/ocaml/preprocess/parser_raw.mly" +# 2503 "src/ocaml/preprocess/parser_raw.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 9501 "src/ocaml/preprocess/parser_raw.ml" +# 8592 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9510,68 +8601,101 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; }; }; }; } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _4 : unit = Obj.magic _4 in let _3 : (Parsetree.expression) = Obj.magic _3 in let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__3_ in + let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = + let _5 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 8655 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 8660 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 8666 "src/ocaml/preprocess/parser_raw.ml" + + in let _2 = let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 9552 "src/ocaml/preprocess/parser_raw.ml" +# 8676 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 9558 "src/ocaml/preprocess/parser_raw.ml" +# 8682 "src/ocaml/preprocess/parser_raw.ml" in -# 2464 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_lazy _3, _2 ) -# 9564 "src/ocaml/preprocess/parser_raw.ml" +# 2555 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_try(_3, _5), _2 ) +# 8688 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos__3_ in + let _endpos__1_ = _endpos_xs_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2397 "src/ocaml/preprocess/parser_raw.mly" +# 2503 "src/ocaml/preprocess/parser_raw.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 9575 "src/ocaml/preprocess/parser_raw.ml" +# 8699 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9584,56 +8708,122 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = xs; - MenhirLib.EngineTypes.startp = _startpos_xs_; - MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.semv = _1_inlined4; + MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _6; + MenhirLib.EngineTypes.startp = _startpos__6_; + MenhirLib.EngineTypes.endp = _endpos__6_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + }; }; } = _menhir_stack in - let xs : ((Asttypes.arg_label * Parsetree.expression) list) = Obj.magic xs in - let _1 : (Parsetree.expression) = Obj.magic _1 in + let _1_inlined4 : (Parsetree.expression) = Obj.magic _1_inlined4 in + let _6 : unit = Obj.magic _6 in + let _1_inlined3 : (Parsetree.expression) = Obj.magic _1_inlined3 in + let _4 : unit = Obj.magic _4 in + let _3 : (Parsetree.expression) = Obj.magic _3 in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos_xs_ in + let _endpos = _endpos__1_inlined4_ in let _v : (Parsetree.expression) = let _1 = - let _1 = + let _7 = + let _1 = _1_inlined4 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 8776 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 8781 "src/ocaml/preprocess/parser_raw.ml" + + in + let _5 = + let _1 = _1_inlined3 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 8789 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 8794 "src/ocaml/preprocess/parser_raw.ml" + + in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in let _2 = - let xs = -# 253 "" - ( List.rev xs ) -# 9610 "src/ocaml/preprocess/parser_raw.ml" - in + let _1 = _1_inlined1 in -# 1092 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 9615 "src/ocaml/preprocess/parser_raw.ml" +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 8804 "src/ocaml/preprocess/parser_raw.ml" in -# 2468 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_apply(_1, _2) ) -# 9621 "src/ocaml/preprocess/parser_raw.ml" +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 8810 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos_xs_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 9631 "src/ocaml/preprocess/parser_raw.ml" +# 2561 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_ifthenelse(_3, (merloc _endpos__4_ _5), Some (merloc _endpos__6_ _7)), _2 ) +# 8816 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos__1_ = _endpos__1_inlined4_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2400 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 9637 "src/ocaml/preprocess/parser_raw.ml" +# 2503 "src/ocaml/preprocess/parser_raw.mly" + ( let desc, attrs = _1 in + mkexp_attrs ~loc:_sloc desc attrs ) +# 8827 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9645,117 +8835,196 @@ module Tables = struct (fun _menhir_env -> let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { - MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = xs; MenhirLib.EngineTypes.startp = _startpos_xs_; MenhirLib.EngineTypes.endp = _endpos_xs_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined6; + MenhirLib.EngineTypes.startp = _startpos__1_inlined6_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined6_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined5; + MenhirLib.EngineTypes.startp = _startpos__1_inlined5_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined4; + MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _6; + MenhirLib.EngineTypes.startp = _startpos__6_; + MenhirLib.EngineTypes.endp = _endpos__6_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + }; + }; + }; + }; + }; } = _menhir_stack in - let xs : (Parsetree.expression list) = Obj.magic xs in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined6 : (Parsetree.attributes) = Obj.magic _1_inlined6 in + let _1_inlined5 : (string Location.loc option) = Obj.magic _1_inlined5 in + let _1_inlined4 : unit = Obj.magic _1_inlined4 in + let _6 : unit = Obj.magic _6 in + let _1_inlined3 : (Parsetree.expression) = Obj.magic _1_inlined3 in + let _4 : unit = Obj.magic _4 in + let _3 : (Parsetree.expression) = Obj.magic _3 in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_xs_ in + let _startpos = _startpos__1_ in let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = - let _1 = + let _7 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined4_, _1_inlined6, _1_inlined5, _1_inlined4) in let _1 = - let es = - let xs = + let _3 = + let xs = + let xs = # 253 "" ( List.rev xs ) -# 9666 "src/ocaml/preprocess/parser_raw.ml" - in +# 8928 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 8933 "src/ocaml/preprocess/parser_raw.ml" + + in -# 1152 "src/ocaml/preprocess/parser_raw.mly" +# 2893 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 9671 "src/ocaml/preprocess/parser_raw.ml" +# 8939 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 8950 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 8956 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2806 "src/ocaml/preprocess/parser_raw.mly" - ( es ) -# 9677 "src/ocaml/preprocess/parser_raw.ml" +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 8976 "src/ocaml/preprocess/parser_raw.ml" in -# 2470 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_tuple(_1) ) -# 9683 "src/ocaml/preprocess/parser_raw.ml" +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 8982 "src/ocaml/preprocess/parser_raw.ml" 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 - -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 9693 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 2400 "src/ocaml/preprocess/parser_raw.mly" + let _5 = + let _1 = _1_inlined3 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 9699 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - } = _menhir_stack in - let _2 : (Parsetree.expression) = Obj.magic _2 in - let _1 : (Longident.t) = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__2_ in - let _v : (Parsetree.expression) = let _1 = - let _1 = - let _1 = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in +# 8990 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 8995 "src/ocaml/preprocess/parser_raw.ml" + + in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in -# 990 "src/ocaml/preprocess/parser_raw.mly" - ( mkrhs _1 _sloc ) -# 9737 "src/ocaml/preprocess/parser_raw.ml" +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9005 "src/ocaml/preprocess/parser_raw.ml" in -# 2472 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_construct(_1, Some _2) ) -# 9743 "src/ocaml/preprocess/parser_raw.ml" +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 9011 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos__2_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 9753 "src/ocaml/preprocess/parser_raw.ml" +# 2561 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_ifthenelse(_3, (merloc _endpos__4_ _5), Some (merloc _endpos__6_ _7)), _2 ) +# 9017 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos__1_ = _endpos_xs_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2400 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 9759 "src/ocaml/preprocess/parser_raw.ml" +# 2503 "src/ocaml/preprocess/parser_raw.mly" + ( let desc, attrs = _1 in + mkexp_attrs ~loc:_sloc desc attrs ) +# 9028 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9768,42 +9037,5355 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.semv = _1_inlined6; + MenhirLib.EngineTypes.startp = _startpos__1_inlined6_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined6_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - } = _menhir_stack in - let _2 : (Parsetree.expression) = Obj.magic _2 in - let _1 : (string) = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__2_ in - let _v : (Parsetree.expression) = let _1 = - let _1 = -# 2474 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_variant(_1, Some _2) ) -# 9792 "src/ocaml/preprocess/parser_raw.ml" + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _6; + MenhirLib.EngineTypes.startp = _startpos__6_; + MenhirLib.EngineTypes.endp = _endpos__6_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined5; + MenhirLib.EngineTypes.startp = _startpos__1_inlined5_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined4; + MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + }; + }; + }; + }; + }; + } = _menhir_stack in + let _1_inlined6 : (Parsetree.expression) = Obj.magic _1_inlined6 in + let _6 : unit = Obj.magic _6 in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined5 : (Parsetree.attributes) = Obj.magic _1_inlined5 in + let _1_inlined4 : (string Location.loc option) = Obj.magic _1_inlined4 in + let _1_inlined3 : unit = Obj.magic _1_inlined3 in + let _4 : unit = Obj.magic _4 in + let _3 : (Parsetree.expression) = Obj.magic _3 in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_inlined6_ in + let _v : (Parsetree.expression) = let _1 = + let _7 = + let _1 = _1_inlined6 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9126 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9131 "src/ocaml/preprocess/parser_raw.ml" + + in + let _5 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined3_, _1_inlined5, _1_inlined4, _1_inlined3) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 9142 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 9147 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 9153 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9164 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 9170 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 9190 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9196 "src/ocaml/preprocess/parser_raw.ml" + + in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9206 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 9212 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2561 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_ifthenelse(_3, (merloc _endpos__4_ _5), Some (merloc _endpos__6_ _7)), _2 ) +# 9218 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__1_ = _endpos__1_inlined6_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2503 "src/ocaml/preprocess/parser_raw.mly" + ( let desc, attrs = _1 in + mkexp_attrs ~loc:_sloc desc attrs ) +# 9229 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs_inlined1; + MenhirLib.EngineTypes.startp = _startpos_xs_inlined1_; + MenhirLib.EngineTypes.endp = _endpos_xs_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined8; + MenhirLib.EngineTypes.startp = _startpos__1_inlined8_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined8_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined7; + MenhirLib.EngineTypes.startp = _startpos__1_inlined7_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined7_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined6; + MenhirLib.EngineTypes.startp = _startpos__1_inlined6_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined6_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _6; + MenhirLib.EngineTypes.startp = _startpos__6_; + MenhirLib.EngineTypes.endp = _endpos__6_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined5; + MenhirLib.EngineTypes.startp = _startpos__1_inlined5_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined4; + MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + }; + }; + }; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs_inlined1 : (Parsetree.case list) = Obj.magic xs_inlined1 in + let _1_inlined8 : (Parsetree.attributes) = Obj.magic _1_inlined8 in + let _1_inlined7 : (string Location.loc option) = Obj.magic _1_inlined7 in + let _1_inlined6 : unit = Obj.magic _1_inlined6 in + let _6 : unit = Obj.magic _6 in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined5 : (Parsetree.attributes) = Obj.magic _1_inlined5 in + let _1_inlined4 : (string Location.loc option) = Obj.magic _1_inlined4 in + let _1_inlined3 : unit = Obj.magic _1_inlined3 in + let _4 : unit = Obj.magic _4 in + let _3 : (Parsetree.expression) = Obj.magic _3 in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos_xs_inlined1_ in + let _v : (Parsetree.expression) = let _1 = + let _7 = + let (_endpos_xs_, _startpos__1_, xs, _1_inlined2, _1_inlined1, _1) = (_endpos_xs_inlined1_, _startpos__1_inlined6_, xs_inlined1, _1_inlined8, _1_inlined7, _1_inlined6) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 9351 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 9356 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 9362 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9373 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 9379 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 9399 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9405 "src/ocaml/preprocess/parser_raw.ml" + + in + let _5 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined3_, _1_inlined5, _1_inlined4, _1_inlined3) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 9416 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 9421 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 9427 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9438 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 9444 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 9464 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9470 "src/ocaml/preprocess/parser_raw.ml" + + in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9480 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 9486 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2561 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_ifthenelse(_3, (merloc _endpos__4_ _5), Some (merloc _endpos__6_ _7)), _2 ) +# 9492 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__1_ = _endpos_xs_inlined1_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2503 "src/ocaml/preprocess/parser_raw.mly" + ( let desc, attrs = _1 in + mkexp_attrs ~loc:_sloc desc attrs ) +# 9503 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let _1_inlined3 : (Parsetree.expression) = Obj.magic _1_inlined3 in + let _4 : unit = Obj.magic _4 in + let _3 : (Parsetree.expression) = Obj.magic _3 in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_inlined3_ in + let _v : (Parsetree.expression) = let _1 = + let _5 = + let _1 = _1_inlined3 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9566 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9571 "src/ocaml/preprocess/parser_raw.ml" + + in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9581 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 9587 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2563 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_ifthenelse(_3, (merloc _endpos__4_ _5), None), _2 ) +# 9593 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__1_ = _endpos__1_inlined3_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2503 "src/ocaml/preprocess/parser_raw.mly" + ( let desc, attrs = _1 in + mkexp_attrs ~loc:_sloc desc attrs ) +# 9604 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined5; + MenhirLib.EngineTypes.startp = _startpos__1_inlined5_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined4; + MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined5 : (Parsetree.attributes) = Obj.magic _1_inlined5 in + let _1_inlined4 : (string Location.loc option) = Obj.magic _1_inlined4 in + let _1_inlined3 : unit = Obj.magic _1_inlined3 in + let _4 : unit = Obj.magic _4 in + let _3 : (Parsetree.expression) = Obj.magic _3 in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _5 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined3_, _1_inlined5, _1_inlined4, _1_inlined3) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 9691 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 9696 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 9702 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9713 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 9719 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 9739 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9745 "src/ocaml/preprocess/parser_raw.ml" + + in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9755 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 9761 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2563 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_ifthenelse(_3, (merloc _endpos__4_ _5), None), _2 ) +# 9767 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__1_ = _endpos_xs_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2503 "src/ocaml/preprocess/parser_raw.mly" + ( let desc, attrs = _1 in + mkexp_attrs ~loc:_sloc desc attrs ) +# 9778 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _6; + MenhirLib.EngineTypes.startp = _startpos__6_; + MenhirLib.EngineTypes.endp = _endpos__6_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + }; + } = _menhir_stack in + let _6 : unit = Obj.magic _6 in + let _5 : (Parsetree.expression) = Obj.magic _5 in + let _4 : unit = Obj.magic _4 in + let _3 : (Parsetree.expression) = Obj.magic _3 in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__6_ in + let _v : (Parsetree.expression) = let _1 = + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9850 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 9856 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2565 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_while(_3, (merloc _endpos__4_ _5)), _2 ) +# 9862 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__1_ = _endpos__6_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2503 "src/ocaml/preprocess/parser_raw.mly" + ( let desc, attrs = _1 in + mkexp_attrs ~loc:_sloc desc attrs ) +# 9873 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _10; + MenhirLib.EngineTypes.startp = _startpos__10_; + MenhirLib.EngineTypes.endp = _endpos__10_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _9; + MenhirLib.EngineTypes.startp = _startpos__9_; + MenhirLib.EngineTypes.endp = _endpos__9_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _8; + MenhirLib.EngineTypes.startp = _startpos__8_; + MenhirLib.EngineTypes.endp = _endpos__8_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _7; + MenhirLib.EngineTypes.startp = _startpos__7_; + MenhirLib.EngineTypes.endp = _endpos__7_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _6; + MenhirLib.EngineTypes.startp = _startpos__6_; + MenhirLib.EngineTypes.endp = _endpos__6_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + }; + }; + }; + }; + }; + } = _menhir_stack in + let _10 : unit = Obj.magic _10 in + let _9 : (Parsetree.expression) = Obj.magic _9 in + let _8 : unit = Obj.magic _8 in + let _7 : (Parsetree.expression) = Obj.magic _7 in + let _6 : (Asttypes.direction_flag) = Obj.magic _6 in + let _5 : (Parsetree.expression) = Obj.magic _5 in + let _4 : unit = Obj.magic _4 in + let _3 : (Parsetree.pattern) = Obj.magic _3 in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__10_ in + let _v : (Parsetree.expression) = let _1 = + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 9973 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 9979 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2572 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_for(_3, (merloc _endpos__4_ _5), (merloc _endpos__6_ _7), _6, (merloc _endpos__8_ _9)), _2 ) +# 9985 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__1_ = _endpos__10_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2503 "src/ocaml/preprocess/parser_raw.mly" + ( let desc, attrs = _1 in + mkexp_attrs ~loc:_sloc desc attrs ) +# 9996 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + } = _menhir_stack in + let _3 : (Parsetree.expression) = Obj.magic _3 in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__3_ in + let _v : (Parsetree.expression) = let _1 = + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10047 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 10053 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2574 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_assert _3, _2 ) +# 10059 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__1_ = _endpos__3_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2503 "src/ocaml/preprocess/parser_raw.mly" + ( let desc, attrs = _1 in + mkexp_attrs ~loc:_sloc desc attrs ) +# 10070 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + } = _menhir_stack in + let _3 : (Parsetree.expression) = Obj.magic _3 in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__3_ in + let _v : (Parsetree.expression) = let _1 = + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10121 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 10127 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2576 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_lazy _3, _2 ) +# 10133 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__1_ = _endpos__3_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2503 "src/ocaml/preprocess/parser_raw.mly" + ( let desc, attrs = _1 in + mkexp_attrs ~loc:_sloc desc attrs ) +# 10144 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + } = _menhir_stack in + let xs : ((Asttypes.arg_label * Parsetree.expression) list) = Obj.magic xs in + let _1 : (Parsetree.expression) = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let _2 = + let xs = +# 253 "" + ( List.rev xs ) +# 10179 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1129 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 10184 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2580 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_apply(_1, _2) ) +# 10190 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__1_ = _endpos_xs_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 10200 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10206 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = _menhir_stack; + } = _menhir_stack in + let xs : (Parsetree.expression list) = Obj.magic xs in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_xs_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let _1 = + let es = + let xs = +# 253 "" + ( List.rev xs ) +# 10235 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1210 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 10240 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2946 "src/ocaml/preprocess/parser_raw.mly" + ( es ) +# 10246 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2582 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_tuple(_1) ) +# 10252 "src/ocaml/preprocess/parser_raw.ml" + + 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 + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 10262 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10268 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + } = _menhir_stack in + let _2 : (Parsetree.expression) = Obj.magic _2 in + let _1 : (Longident.t) = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__2_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let _1 = + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1027 "src/ocaml/preprocess/parser_raw.mly" + ( mkrhs _1 _sloc ) +# 10306 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2584 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_construct(_1, Some _2) ) +# 10312 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__1_ = _endpos__2_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 10322 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10328 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + } = _menhir_stack in + let _2 : (Parsetree.expression) = Obj.magic _2 in + let _1 : (string) = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__2_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = +# 2586 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_variant(_1, Some _2) ) +# 10361 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 10370 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10376 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = op; + MenhirLib.EngineTypes.startp = _startpos_op_; + MenhirLib.EngineTypes.endp = _endpos_op_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1 : (Parsetree.expression) = Obj.magic _1 in + let op : ( +# 814 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 10410 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic op in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10422 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10427 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3933 "src/ocaml/preprocess/parser_raw.mly" + ( op ) +# 10434 "src/ocaml/preprocess/parser_raw.ml" + in + let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 10443 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 10449 "src/ocaml/preprocess/parser_raw.ml" + + in + let _startpos__1_ = _startpos_e1_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 10459 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10465 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = op; + MenhirLib.EngineTypes.startp = _startpos_op_; + MenhirLib.EngineTypes.endp = _endpos_op_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let op : ( +# 814 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 10520 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic op in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 10535 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 10540 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 10546 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10557 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 10563 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 10583 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10589 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3933 "src/ocaml/preprocess/parser_raw.mly" + ( op ) +# 10596 "src/ocaml/preprocess/parser_raw.ml" + in + let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 10605 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 10611 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 10621 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10627 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = op; + MenhirLib.EngineTypes.startp = _startpos_op_; + MenhirLib.EngineTypes.endp = _endpos_op_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1 : (Parsetree.expression) = Obj.magic _1 in + let op : ( +# 815 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 10661 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic op in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10673 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10678 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3934 "src/ocaml/preprocess/parser_raw.mly" + ( op ) +# 10685 "src/ocaml/preprocess/parser_raw.ml" + in + let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 10694 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 10700 "src/ocaml/preprocess/parser_raw.ml" + + in + let _startpos__1_ = _startpos_e1_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 10710 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10716 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = op; + MenhirLib.EngineTypes.startp = _startpos_op_; + MenhirLib.EngineTypes.endp = _endpos_op_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let op : ( +# 815 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 10771 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic op in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 10786 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 10791 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 10797 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10808 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 10814 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 10834 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10840 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3934 "src/ocaml/preprocess/parser_raw.mly" + ( op ) +# 10847 "src/ocaml/preprocess/parser_raw.ml" + in + let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 10856 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 10862 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 10872 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10878 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = op; + MenhirLib.EngineTypes.startp = _startpos_op_; + MenhirLib.EngineTypes.endp = _endpos_op_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1 : (Parsetree.expression) = Obj.magic _1 in + let op : ( +# 816 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 10912 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic op in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10924 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10929 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3935 "src/ocaml/preprocess/parser_raw.mly" + ( op ) +# 10936 "src/ocaml/preprocess/parser_raw.ml" + in + let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 10945 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 10951 "src/ocaml/preprocess/parser_raw.ml" + + in + let _startpos__1_ = _startpos_e1_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 10961 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 10967 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = op; + MenhirLib.EngineTypes.startp = _startpos_op_; + MenhirLib.EngineTypes.endp = _endpos_op_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let op : ( +# 816 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 11022 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic op in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 11037 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 11042 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 11048 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11059 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 11065 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 11085 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11091 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3935 "src/ocaml/preprocess/parser_raw.mly" + ( op ) +# 11098 "src/ocaml/preprocess/parser_raw.ml" + in + let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 11107 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 11113 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 11123 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11129 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = op; + MenhirLib.EngineTypes.startp = _startpos_op_; + MenhirLib.EngineTypes.endp = _endpos_op_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1 : (Parsetree.expression) = Obj.magic _1 in + let op : ( +# 817 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 11163 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic op in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11175 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11180 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3936 "src/ocaml/preprocess/parser_raw.mly" + ( op ) +# 11187 "src/ocaml/preprocess/parser_raw.ml" + in + let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 11196 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 11202 "src/ocaml/preprocess/parser_raw.ml" + + in + let _startpos__1_ = _startpos_e1_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 11212 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11218 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = op; + MenhirLib.EngineTypes.startp = _startpos_op_; + MenhirLib.EngineTypes.endp = _endpos_op_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let op : ( +# 817 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 11273 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic op in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 11288 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 11293 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 11299 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11310 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 11316 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 11336 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11342 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3936 "src/ocaml/preprocess/parser_raw.mly" + ( op ) +# 11349 "src/ocaml/preprocess/parser_raw.ml" + in + let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 11358 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 11364 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 11374 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11380 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = op; + MenhirLib.EngineTypes.startp = _startpos_op_; + MenhirLib.EngineTypes.endp = _endpos_op_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1 : (Parsetree.expression) = Obj.magic _1 in + let op : ( +# 818 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 11414 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic op in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11426 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11431 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3937 "src/ocaml/preprocess/parser_raw.mly" + ( op ) +# 11438 "src/ocaml/preprocess/parser_raw.ml" + in + let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 11447 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 11453 "src/ocaml/preprocess/parser_raw.ml" + + in + let _startpos__1_ = _startpos_e1_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 11463 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11469 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = op; + MenhirLib.EngineTypes.startp = _startpos_op_; + MenhirLib.EngineTypes.endp = _endpos_op_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let op : ( +# 818 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 11524 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic op in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 11539 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 11544 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 11550 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11561 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 11567 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 11587 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11593 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3937 "src/ocaml/preprocess/parser_raw.mly" + ( op ) +# 11600 "src/ocaml/preprocess/parser_raw.ml" + in + let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 11609 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 11615 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 11625 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11631 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11674 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11679 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3938 "src/ocaml/preprocess/parser_raw.mly" + ("+") +# 11686 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 11694 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 11700 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 11710 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11716 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 11783 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 11788 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 11794 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11805 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 11811 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 11831 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11837 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3938 "src/ocaml/preprocess/parser_raw.mly" + ("+") +# 11844 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 11852 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 11858 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 11868 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11874 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11917 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11922 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3939 "src/ocaml/preprocess/parser_raw.mly" + ("+.") +# 11929 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 11937 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 11943 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 11953 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 11959 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 12026 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 12031 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 12037 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12048 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 12054 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 12074 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12080 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3939 "src/ocaml/preprocess/parser_raw.mly" + ("+.") +# 12087 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 12095 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 12101 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 12111 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12117 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12160 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12165 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3940 "src/ocaml/preprocess/parser_raw.mly" + ("+=") +# 12172 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 12180 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 12186 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 12196 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12202 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 12269 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 12274 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 12280 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12291 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 12297 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 12317 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12323 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3940 "src/ocaml/preprocess/parser_raw.mly" + ("+=") +# 12330 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 12338 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 12344 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 12354 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12360 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12403 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12408 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3941 "src/ocaml/preprocess/parser_raw.mly" + ("-") +# 12415 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 12423 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 12429 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 12439 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12445 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 12512 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 12517 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 12523 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12534 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 12540 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 12560 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12566 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3941 "src/ocaml/preprocess/parser_raw.mly" + ("-") +# 12573 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 12581 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 12587 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 12597 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12603 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12646 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12651 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3942 "src/ocaml/preprocess/parser_raw.mly" + ("-.") +# 12658 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 12666 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 12672 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 12682 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12688 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 12755 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 12760 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 12766 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12777 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 12783 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 12803 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12809 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3942 "src/ocaml/preprocess/parser_raw.mly" + ("-.") +# 12816 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 12824 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 12830 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 12840 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12846 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12889 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12894 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3943 "src/ocaml/preprocess/parser_raw.mly" + ("*") +# 12901 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 12909 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 12915 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 12925 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 12931 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 12998 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 13003 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 13009 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13020 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 13026 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 13046 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13052 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3943 "src/ocaml/preprocess/parser_raw.mly" + ("*") +# 13059 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 13067 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 13073 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 13083 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13089 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13132 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13137 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3944 "src/ocaml/preprocess/parser_raw.mly" + ("%") +# 13144 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 13152 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 13158 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 13168 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13174 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 13241 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 13246 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 13252 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13263 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 13269 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 13289 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13295 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3944 "src/ocaml/preprocess/parser_raw.mly" + ("%") +# 13302 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 13310 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 13316 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 13326 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13332 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13375 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13380 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3945 "src/ocaml/preprocess/parser_raw.mly" + ("=") +# 13387 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 13395 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 13401 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 13411 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13417 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 13484 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 13489 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 13495 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13506 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 13512 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 13532 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13538 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3945 "src/ocaml/preprocess/parser_raw.mly" + ("=") +# 13545 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 13553 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 13559 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 13569 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13575 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13618 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13623 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3946 "src/ocaml/preprocess/parser_raw.mly" + ("<") +# 13630 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 13638 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 13644 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 13654 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13660 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 13727 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 13732 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 13738 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13749 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 13755 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 13775 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13781 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3946 "src/ocaml/preprocess/parser_raw.mly" + ("<") +# 13788 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 13796 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 13802 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 13812 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13818 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13861 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13866 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3947 "src/ocaml/preprocess/parser_raw.mly" + (">") +# 13873 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 13881 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 13887 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 13897 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13903 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 13970 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 13975 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 13981 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 13992 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 13998 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 14018 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14024 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3947 "src/ocaml/preprocess/parser_raw.mly" + (">") +# 14031 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 14039 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 14045 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 14055 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14061 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14104 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14109 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3948 "src/ocaml/preprocess/parser_raw.mly" + ("or") +# 14116 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 14124 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 14130 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 14140 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14146 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 14213 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 14218 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 14224 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14235 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 14241 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 14261 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14267 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3948 "src/ocaml/preprocess/parser_raw.mly" + ("or") +# 14274 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 14282 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 14288 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 14298 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14304 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let e1 : (Parsetree.expression) = Obj.magic e1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_e1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14347 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14352 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3949 "src/ocaml/preprocess/parser_raw.mly" + ("||") +# 14359 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 14367 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 14373 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 9801 "src/ocaml/preprocess/parser_raw.ml" +# 14383 "src/ocaml/preprocess/parser_raw.ml" in -# 2400 "src/ocaml/preprocess/parser_raw.mly" +# 2506 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 9807 "src/ocaml/preprocess/parser_raw.ml" +# 14389 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9816,71 +14398,152 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = op; - MenhirLib.EngineTypes.startp = _startpos_op_; - MenhirLib.EngineTypes.endp = _endpos_op_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in - let op : ( -# 769 "src/ocaml/preprocess/parser_raw.mly" - (string) -# 9841 "src/ocaml/preprocess/parser_raw.ml" - ) = Obj.magic op in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in let e1 : (Parsetree.expression) = Obj.magic e1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in + let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = let _1 = + let e2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 14456 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 14461 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 14467 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14478 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 14484 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 14504 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14510 "src/ocaml/preprocess/parser_raw.ml" + + in let op = let _1 = -# 3737 "src/ocaml/preprocess/parser_raw.mly" - ( op ) -# 9853 "src/ocaml/preprocess/parser_raw.ml" +# 3949 "src/ocaml/preprocess/parser_raw.mly" + ("||") +# 14517 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1017 "src/ocaml/preprocess/parser_raw.mly" +# 1054 "src/ocaml/preprocess/parser_raw.mly" ( mkoperator ~loc:_sloc _1 ) -# 9862 "src/ocaml/preprocess/parser_raw.ml" +# 14525 "src/ocaml/preprocess/parser_raw.ml" in -# 2476 "src/ocaml/preprocess/parser_raw.mly" +# 2588 "src/ocaml/preprocess/parser_raw.mly" ( mkinfix e1 op e2 ) -# 9868 "src/ocaml/preprocess/parser_raw.ml" +# 14531 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 9878 "src/ocaml/preprocess/parser_raw.ml" +# 14541 "src/ocaml/preprocess/parser_raw.ml" in -# 2400 "src/ocaml/preprocess/parser_raw.mly" +# 2506 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 9884 "src/ocaml/preprocess/parser_raw.ml" +# 14547 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9893,14 +14556,14 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = op; - MenhirLib.EngineTypes.startp = _startpos_op_; - MenhirLib.EngineTypes.endp = _endpos_op_; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _menhir_s; MenhirLib.EngineTypes.semv = e1; @@ -9910,54 +14573,62 @@ module Tables = struct }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in - let op : ( -# 770 "src/ocaml/preprocess/parser_raw.mly" - (string) -# 9918 "src/ocaml/preprocess/parser_raw.ml" - ) = Obj.magic op in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in let e1 : (Parsetree.expression) = Obj.magic e1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in + let _endpos = _endpos__1_inlined1_ in let _v : (Parsetree.expression) = let _1 = let _1 = + let e2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14590 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14595 "src/ocaml/preprocess/parser_raw.ml" + + in let op = let _1 = -# 3738 "src/ocaml/preprocess/parser_raw.mly" - ( op ) -# 9930 "src/ocaml/preprocess/parser_raw.ml" +# 3950 "src/ocaml/preprocess/parser_raw.mly" + ("&") +# 14602 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1017 "src/ocaml/preprocess/parser_raw.mly" +# 1054 "src/ocaml/preprocess/parser_raw.mly" ( mkoperator ~loc:_sloc _1 ) -# 9939 "src/ocaml/preprocess/parser_raw.ml" +# 14610 "src/ocaml/preprocess/parser_raw.ml" in -# 2476 "src/ocaml/preprocess/parser_raw.mly" +# 2588 "src/ocaml/preprocess/parser_raw.mly" ( mkinfix e1 op e2 ) -# 9945 "src/ocaml/preprocess/parser_raw.ml" +# 14616 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_e1_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 9955 "src/ocaml/preprocess/parser_raw.ml" +# 14626 "src/ocaml/preprocess/parser_raw.ml" in -# 2400 "src/ocaml/preprocess/parser_raw.mly" +# 2506 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 9961 "src/ocaml/preprocess/parser_raw.ml" +# 14632 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -9970,71 +14641,152 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = op; - MenhirLib.EngineTypes.startp = _startpos_op_; - MenhirLib.EngineTypes.endp = _endpos_op_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in - let op : ( -# 771 "src/ocaml/preprocess/parser_raw.mly" - (string) -# 9995 "src/ocaml/preprocess/parser_raw.ml" - ) = Obj.magic op in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in let e1 : (Parsetree.expression) = Obj.magic e1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in + let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = let _1 = + let e2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 14699 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 14704 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 14710 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14721 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 14727 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 14747 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14753 "src/ocaml/preprocess/parser_raw.ml" + + in let op = let _1 = -# 3739 "src/ocaml/preprocess/parser_raw.mly" - ( op ) -# 10007 "src/ocaml/preprocess/parser_raw.ml" +# 3950 "src/ocaml/preprocess/parser_raw.mly" + ("&") +# 14760 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1017 "src/ocaml/preprocess/parser_raw.mly" +# 1054 "src/ocaml/preprocess/parser_raw.mly" ( mkoperator ~loc:_sloc _1 ) -# 10016 "src/ocaml/preprocess/parser_raw.ml" +# 14768 "src/ocaml/preprocess/parser_raw.ml" in -# 2476 "src/ocaml/preprocess/parser_raw.mly" +# 2588 "src/ocaml/preprocess/parser_raw.mly" ( mkinfix e1 op e2 ) -# 10022 "src/ocaml/preprocess/parser_raw.ml" +# 14774 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 10032 "src/ocaml/preprocess/parser_raw.ml" +# 14784 "src/ocaml/preprocess/parser_raw.ml" in -# 2400 "src/ocaml/preprocess/parser_raw.mly" +# 2506 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 10038 "src/ocaml/preprocess/parser_raw.ml" +# 14790 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10047,14 +14799,14 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = op; - MenhirLib.EngineTypes.startp = _startpos_op_; - MenhirLib.EngineTypes.endp = _endpos_op_; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _menhir_s; MenhirLib.EngineTypes.semv = e1; @@ -10064,54 +14816,62 @@ module Tables = struct }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in - let op : ( -# 772 "src/ocaml/preprocess/parser_raw.mly" - (string) -# 10072 "src/ocaml/preprocess/parser_raw.ml" - ) = Obj.magic op in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in let e1 : (Parsetree.expression) = Obj.magic e1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in + let _endpos = _endpos__1_inlined1_ in let _v : (Parsetree.expression) = let _1 = let _1 = + let e2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14833 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14838 "src/ocaml/preprocess/parser_raw.ml" + + in let op = let _1 = -# 3740 "src/ocaml/preprocess/parser_raw.mly" - ( op ) -# 10084 "src/ocaml/preprocess/parser_raw.ml" +# 3951 "src/ocaml/preprocess/parser_raw.mly" + ("&&") +# 14845 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1017 "src/ocaml/preprocess/parser_raw.mly" +# 1054 "src/ocaml/preprocess/parser_raw.mly" ( mkoperator ~loc:_sloc _1 ) -# 10093 "src/ocaml/preprocess/parser_raw.ml" +# 14853 "src/ocaml/preprocess/parser_raw.ml" in -# 2476 "src/ocaml/preprocess/parser_raw.mly" +# 2588 "src/ocaml/preprocess/parser_raw.mly" ( mkinfix e1 op e2 ) -# 10099 "src/ocaml/preprocess/parser_raw.ml" +# 14859 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_e1_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 10109 "src/ocaml/preprocess/parser_raw.ml" +# 14869 "src/ocaml/preprocess/parser_raw.ml" in -# 2400 "src/ocaml/preprocess/parser_raw.mly" +# 2506 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 10115 "src/ocaml/preprocess/parser_raw.ml" +# 14875 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10124,71 +14884,152 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = op; - MenhirLib.EngineTypes.startp = _startpos_op_; - MenhirLib.EngineTypes.endp = _endpos_op_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in - let op : ( -# 773 "src/ocaml/preprocess/parser_raw.mly" - (string) -# 10149 "src/ocaml/preprocess/parser_raw.ml" - ) = Obj.magic op in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in let e1 : (Parsetree.expression) = Obj.magic e1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in + let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = let _1 = + let e2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 14942 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 14947 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 14953 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14964 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 14970 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 14990 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 14996 "src/ocaml/preprocess/parser_raw.ml" + + in let op = let _1 = -# 3741 "src/ocaml/preprocess/parser_raw.mly" - ( op ) -# 10161 "src/ocaml/preprocess/parser_raw.ml" +# 3951 "src/ocaml/preprocess/parser_raw.mly" + ("&&") +# 15003 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1017 "src/ocaml/preprocess/parser_raw.mly" +# 1054 "src/ocaml/preprocess/parser_raw.mly" ( mkoperator ~loc:_sloc _1 ) -# 10170 "src/ocaml/preprocess/parser_raw.ml" +# 15011 "src/ocaml/preprocess/parser_raw.ml" in -# 2476 "src/ocaml/preprocess/parser_raw.mly" +# 2588 "src/ocaml/preprocess/parser_raw.mly" ( mkinfix e1 op e2 ) -# 10176 "src/ocaml/preprocess/parser_raw.ml" +# 15017 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 10186 "src/ocaml/preprocess/parser_raw.ml" +# 15027 "src/ocaml/preprocess/parser_raw.ml" in -# 2400 "src/ocaml/preprocess/parser_raw.mly" +# 2506 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 10192 "src/ocaml/preprocess/parser_raw.ml" +# 15033 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10201,9 +15042,9 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _1; @@ -10218,49 +15059,62 @@ module Tables = struct }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let e1 : (Parsetree.expression) = Obj.magic e1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in + let _endpos = _endpos__1_inlined1_ in let _v : (Parsetree.expression) = let _1 = let _1 = + let e2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15076 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15081 "src/ocaml/preprocess/parser_raw.ml" + + in let op = let _1 = -# 3742 "src/ocaml/preprocess/parser_raw.mly" - ("+") -# 10234 "src/ocaml/preprocess/parser_raw.ml" +# 3952 "src/ocaml/preprocess/parser_raw.mly" + (":=") +# 15088 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1017 "src/ocaml/preprocess/parser_raw.mly" +# 1054 "src/ocaml/preprocess/parser_raw.mly" ( mkoperator ~loc:_sloc _1 ) -# 10242 "src/ocaml/preprocess/parser_raw.ml" +# 15096 "src/ocaml/preprocess/parser_raw.ml" in -# 2476 "src/ocaml/preprocess/parser_raw.mly" +# 2588 "src/ocaml/preprocess/parser_raw.mly" ( mkinfix e1 op e2 ) -# 10248 "src/ocaml/preprocess/parser_raw.ml" +# 15102 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_e1_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 10258 "src/ocaml/preprocess/parser_raw.ml" +# 15112 "src/ocaml/preprocess/parser_raw.ml" in -# 2400 "src/ocaml/preprocess/parser_raw.mly" +# 2506 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 10264 "src/ocaml/preprocess/parser_raw.ml" +# 15118 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10273,66 +15127,353 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = e1; + MenhirLib.EngineTypes.startp = _startpos_e1_; + MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let e1 : (Parsetree.expression) = Obj.magic e1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in + let _startpos = _startpos_e1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let e2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 15185 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 15190 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 15196 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15207 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 15213 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 15233 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15239 "src/ocaml/preprocess/parser_raw.ml" + + in + let op = + let _1 = +# 3952 "src/ocaml/preprocess/parser_raw.mly" + (":=") +# 15246 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1054 "src/ocaml/preprocess/parser_raw.mly" + ( mkoperator ~loc:_sloc _1 ) +# 15254 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2588 "src/ocaml/preprocess/parser_raw.mly" + ( mkinfix e1 op e2 ) +# 15260 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_e1_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 15270 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15276 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + } = _menhir_stack in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : (string) = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = + let _2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15312 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15317 "src/ocaml/preprocess/parser_raw.ml" + + in + let _loc__1_ = (_startpos__1_, _endpos__1_) in + +# 2590 "src/ocaml/preprocess/parser_raw.mly" + ( mkuminus ~oploc:_loc__1_ _1 _2 ) +# 15324 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__1_ = _endpos__1_inlined1_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 15334 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2506 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15340 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : (string) = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = let _1 = - let op = - let _1 = -# 3743 "src/ocaml/preprocess/parser_raw.mly" - ("+.") -# 10306 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in + let _2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 15400 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 15405 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 15411 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15422 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 15428 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 15448 "src/ocaml/preprocess/parser_raw.ml" + + in -# 1017 "src/ocaml/preprocess/parser_raw.mly" - ( mkoperator ~loc:_sloc _1 ) -# 10314 "src/ocaml/preprocess/parser_raw.ml" +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15454 "src/ocaml/preprocess/parser_raw.ml" in + let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2476 "src/ocaml/preprocess/parser_raw.mly" - ( mkinfix e1 op e2 ) -# 10320 "src/ocaml/preprocess/parser_raw.ml" +# 2590 "src/ocaml/preprocess/parser_raw.mly" + ( mkuminus ~oploc:_loc__1_ _1 _2 ) +# 15461 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in + let _endpos__1_ = _endpos_xs_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 10330 "src/ocaml/preprocess/parser_raw.ml" +# 15471 "src/ocaml/preprocess/parser_raw.ml" in -# 2400 "src/ocaml/preprocess/parser_raw.mly" +# 2506 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 10336 "src/ocaml/preprocess/parser_raw.ml" +# 15477 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10345,66 +15486,58 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.state = _menhir_s; MenhirLib.EngineTypes.semv = _1; MenhirLib.EngineTypes.startp = _startpos__1_; MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; + MenhirLib.EngineTypes.next = _menhir_stack; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in - let _1 : unit = Obj.magic _1 in - let e1 : (Parsetree.expression) = Obj.magic e1 in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : (string) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_inlined1_ in let _v : (Parsetree.expression) = let _1 = let _1 = - let op = + let _2 = + let _1 = _1_inlined1 in let _1 = -# 3744 "src/ocaml/preprocess/parser_raw.mly" - ("+=") -# 10378 "src/ocaml/preprocess/parser_raw.ml" +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15513 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in -# 1017 "src/ocaml/preprocess/parser_raw.mly" - ( mkoperator ~loc:_sloc _1 ) -# 10386 "src/ocaml/preprocess/parser_raw.ml" +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15518 "src/ocaml/preprocess/parser_raw.ml" in + let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2476 "src/ocaml/preprocess/parser_raw.mly" - ( mkinfix e1 op e2 ) -# 10392 "src/ocaml/preprocess/parser_raw.ml" +# 2592 "src/ocaml/preprocess/parser_raw.mly" + ( mkuplus ~oploc:_loc__1_ _1 _2 ) +# 15525 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in + let _endpos__1_ = _endpos__1_inlined1_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 10402 "src/ocaml/preprocess/parser_raw.ml" +# 15535 "src/ocaml/preprocess/parser_raw.ml" in -# 2400 "src/ocaml/preprocess/parser_raw.mly" +# 2506 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 10408 "src/ocaml/preprocess/parser_raw.ml" +# 15541 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10417,66 +15550,131 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in - let _1 : unit = Obj.magic _1 in - let e1 : (Parsetree.expression) = Obj.magic e1 in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : (string) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in + let _startpos = _startpos__1_ in + let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = let _1 = - let op = - let _1 = -# 3745 "src/ocaml/preprocess/parser_raw.mly" - ("-") -# 10450 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in + let _2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 15601 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 15606 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 15612 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15623 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 15629 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 15649 "src/ocaml/preprocess/parser_raw.ml" + + in -# 1017 "src/ocaml/preprocess/parser_raw.mly" - ( mkoperator ~loc:_sloc _1 ) -# 10458 "src/ocaml/preprocess/parser_raw.ml" +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15655 "src/ocaml/preprocess/parser_raw.ml" in + let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 2476 "src/ocaml/preprocess/parser_raw.mly" - ( mkinfix e1 op e2 ) -# 10464 "src/ocaml/preprocess/parser_raw.ml" +# 2592 "src/ocaml/preprocess/parser_raw.mly" + ( mkuplus ~oploc:_loc__1_ _1 _2 ) +# 15662 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in + let _endpos__1_ = _endpos_xs_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 10474 "src/ocaml/preprocess/parser_raw.ml" +# 15672 "src/ocaml/preprocess/parser_raw.ml" in -# 2400 "src/ocaml/preprocess/parser_raw.mly" +# 2506 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 10480 "src/ocaml/preprocess/parser_raw.ml" +# 15678 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10489,66 +15687,36 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in - let _1 : unit = Obj.magic _1 in - let e1 : (Parsetree.expression) = Obj.magic e1 in + let _3 : (Parsetree.expression) = Obj.magic _3 in + let _2 : unit = Obj.magic _2 in + let _1 : (Ast_helper.let_bindings) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in - let _v : (Parsetree.expression) = let _1 = - let _1 = - let op = - let _1 = -# 3746 "src/ocaml/preprocess/parser_raw.mly" - ("-.") -# 10522 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1017 "src/ocaml/preprocess/parser_raw.mly" - ( mkoperator ~loc:_sloc _1 ) -# 10530 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 2476 "src/ocaml/preprocess/parser_raw.mly" - ( mkinfix e1 op e2 ) -# 10536 "src/ocaml/preprocess/parser_raw.ml" - - in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 10546 "src/ocaml/preprocess/parser_raw.ml" - - in + let _startpos = _startpos__1_ in + let _endpos = _endpos__3_ in + let _v : (Parsetree.expression) = let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2400 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 10552 "src/ocaml/preprocess/parser_raw.ml" +# 2508 "src/ocaml/preprocess/parser_raw.mly" + ( expr_of_let_bindings ~loc:_sloc _1 (merloc _endpos__2_ _3) ) +# 15720 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10561,66 +15729,62 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = body; + MenhirLib.EngineTypes.startp = _startpos_body_; + MenhirLib.EngineTypes.endp = _endpos_body_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = bindings; + MenhirLib.EngineTypes.startp = _startpos_bindings_; + MenhirLib.EngineTypes.endp = _endpos_bindings_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in - let _1 : unit = Obj.magic _1 in - let e1 : (Parsetree.expression) = Obj.magic e1 in + let body : (Parsetree.expression) = Obj.magic body in + let _3 : unit = Obj.magic _3 in + let bindings : (Parsetree.pattern * Parsetree.expression * Parsetree.binding_op list) = Obj.magic bindings in + let _1 : ( +# 820 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 15762 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in - let _v : (Parsetree.expression) = let _1 = - let _1 = - let op = - let _1 = -# 3747 "src/ocaml/preprocess/parser_raw.mly" - ("*") -# 10594 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1017 "src/ocaml/preprocess/parser_raw.mly" - ( mkoperator ~loc:_sloc _1 ) -# 10602 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 2476 "src/ocaml/preprocess/parser_raw.mly" - ( mkinfix e1 op e2 ) -# 10608 "src/ocaml/preprocess/parser_raw.ml" - - in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in + let _startpos = _startpos__1_ in + let _endpos = _endpos_body_ in + let _v : (Parsetree.expression) = let pbop_op = let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 10618 "src/ocaml/preprocess/parser_raw.ml" +# 1027 "src/ocaml/preprocess/parser_raw.mly" + ( mkrhs _1 _sloc ) +# 15774 "src/ocaml/preprocess/parser_raw.ml" in + let _startpos_pbop_op_ = _startpos__1_ in + let _endpos = _endpos_body_ in + let _symbolstartpos = _startpos_pbop_op_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2400 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 10624 "src/ocaml/preprocess/parser_raw.ml" +# 2510 "src/ocaml/preprocess/parser_raw.mly" + ( let (pbop_pat, pbop_exp, rev_ands) = bindings in + let ands = List.rev rev_ands in + let pbop_loc = make_loc _sloc in + let let_ = {pbop_op; pbop_pat; pbop_exp; pbop_loc} in + mkexp ~loc:_sloc (Pexp_letop{ let_; ands; body}) ) +# 15788 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10633,66 +15797,51 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in - let _1 : unit = Obj.magic _1 in - let e1 : (Parsetree.expression) = Obj.magic e1 in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in + let _1 : (Parsetree.expression) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in - let _v : (Parsetree.expression) = let _1 = - let _1 = - let op = - let _1 = -# 3748 "src/ocaml/preprocess/parser_raw.mly" - ("%") -# 10666 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1017 "src/ocaml/preprocess/parser_raw.mly" - ( mkoperator ~loc:_sloc _1 ) -# 10674 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 2476 "src/ocaml/preprocess/parser_raw.mly" - ( mkinfix e1 op e2 ) -# 10680 "src/ocaml/preprocess/parser_raw.ml" - - in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression) = let _3 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15829 "src/ocaml/preprocess/parser_raw.ml" + in -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 10690 "src/ocaml/preprocess/parser_raw.ml" +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15834 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos__3_ = _endpos__1_inlined1_ in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _loc__2_ = (_startpos__2_, _endpos__2_) in + let _sloc = (_symbolstartpos, _endpos) in -# 2400 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 10696 "src/ocaml/preprocess/parser_raw.ml" +# 2516 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp_cons ~loc:_sloc _loc__2_ (ghexp ~loc:_sloc (Pexp_tuple[_1;(merloc _endpos__2_ _3)])) ) +# 15845 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10705,66 +15854,124 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in - let _1 : unit = Obj.magic _1 in - let e1 : (Parsetree.expression) = Obj.magic e1 in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in + let _1 : (Parsetree.expression) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in - let _v : (Parsetree.expression) = let _1 = + let _startpos = _startpos__1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _3 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in let _1 = - let op = - let _1 = -# 3749 "src/ocaml/preprocess/parser_raw.mly" - ("=") -# 10738 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 15910 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 15915 "src/ocaml/preprocess/parser_raw.ml" + + in -# 1017 "src/ocaml/preprocess/parser_raw.mly" - ( mkoperator ~loc:_sloc _1 ) -# 10746 "src/ocaml/preprocess/parser_raw.ml" +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 15921 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15932 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 15938 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2476 "src/ocaml/preprocess/parser_raw.mly" - ( mkinfix e1 op e2 ) -# 10752 "src/ocaml/preprocess/parser_raw.ml" +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 15958 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 10762 "src/ocaml/preprocess/parser_raw.ml" +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 15964 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos__3_ = _endpos_xs_ in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _loc__2_ = (_startpos__2_, _endpos__2_) in + let _sloc = (_symbolstartpos, _endpos) in -# 2400 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 10768 "src/ocaml/preprocess/parser_raw.ml" +# 2516 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp_cons ~loc:_sloc _loc__2_ (ghexp ~loc:_sloc (Pexp_tuple[_1;(merloc _endpos__2_ _3)])) ) +# 15975 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10777,66 +15984,69 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in - let _1 : unit = Obj.magic _1 in - let e1 : (Parsetree.expression) = Obj.magic e1 in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in + let _1 : ( +# 838 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 16010 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in - let _v : (Parsetree.expression) = let _1 = - let _1 = - let op = - let _1 = -# 3750 "src/ocaml/preprocess/parser_raw.mly" - ("<") -# 10810 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1017 "src/ocaml/preprocess/parser_raw.mly" - ( mkoperator ~loc:_sloc _1 ) -# 10818 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 2476 "src/ocaml/preprocess/parser_raw.mly" - ( mkinfix e1 op e2 ) -# 10824 "src/ocaml/preprocess/parser_raw.ml" - - in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression) = let _3 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16020 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16025 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos__1_inlined1_ in + let _1 = + let _1 = +# 3881 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16033 "src/ocaml/preprocess/parser_raw.ml" + in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 10834 "src/ocaml/preprocess/parser_raw.ml" +# 1027 "src/ocaml/preprocess/parser_raw.mly" + ( mkrhs _1 _sloc ) +# 16041 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2400 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 10840 "src/ocaml/preprocess/parser_raw.ml" +# 2518 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc (Pexp_setinstvar(_1, _3)) ) +# 16050 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10849,66 +16059,142 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in - let _1 : unit = Obj.magic _1 in - let e1 : (Parsetree.expression) = Obj.magic e1 in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in + let _1 : ( +# 838 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 16106 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in - let _v : (Parsetree.expression) = let _1 = + let _startpos = _startpos__1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _3 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in let _1 = - let op = - let _1 = -# 3751 "src/ocaml/preprocess/parser_raw.mly" - (">") -# 10882 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 16119 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 16124 "src/ocaml/preprocess/parser_raw.ml" + + in -# 1017 "src/ocaml/preprocess/parser_raw.mly" - ( mkoperator ~loc:_sloc _1 ) -# 10890 "src/ocaml/preprocess/parser_raw.ml" +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 16130 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16141 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 16147 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2476 "src/ocaml/preprocess/parser_raw.mly" - ( mkinfix e1 op e2 ) -# 10896 "src/ocaml/preprocess/parser_raw.ml" +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 16167 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16173 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _1 = + let _1 = +# 3881 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16181 "src/ocaml/preprocess/parser_raw.ml" + in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 10906 "src/ocaml/preprocess/parser_raw.ml" +# 1027 "src/ocaml/preprocess/parser_raw.mly" + ( mkrhs _1 _sloc ) +# 16189 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2400 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 10912 "src/ocaml/preprocess/parser_raw.ml" +# 2518 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc (Pexp_setinstvar(_1, _3)) ) +# 16198 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10921,66 +16207,75 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in - let _1 : unit = Obj.magic _1 in - let e1 : (Parsetree.expression) = Obj.magic e1 in + let _1_inlined2 : (Parsetree.expression) = Obj.magic _1_inlined2 in + let _4 : unit = Obj.magic _4 in + let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in + let _1 : (Parsetree.expression) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in - let _v : (Parsetree.expression) = let _1 = - let _1 = - let op = - let _1 = -# 3752 "src/ocaml/preprocess/parser_raw.mly" - ("or") -# 10954 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1017 "src/ocaml/preprocess/parser_raw.mly" - ( mkoperator ~loc:_sloc _1 ) -# 10962 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 2476 "src/ocaml/preprocess/parser_raw.mly" - ( mkinfix e1 op e2 ) -# 10968 "src/ocaml/preprocess/parser_raw.ml" - - in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_inlined2_ in + let _v : (Parsetree.expression) = let _5 = + let _1 = _1_inlined2 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16253 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16258 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__5_ = _endpos__1_inlined2_ in + let _3 = + let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 10978 "src/ocaml/preprocess/parser_raw.ml" +# 1027 "src/ocaml/preprocess/parser_raw.mly" + ( mkrhs _1 _sloc ) +# 16270 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos = _endpos__5_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2400 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 10984 "src/ocaml/preprocess/parser_raw.ml" +# 2520 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc (Pexp_setfield(_1, _3, _5)) ) +# 16279 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -10993,66 +16288,148 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _1_inlined4; + MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in - let _1 : unit = Obj.magic _1 in - let e1 : (Parsetree.expression) = Obj.magic e1 in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in + let _1_inlined3 : (string Location.loc option) = Obj.magic _1_inlined3 in + let _1_inlined2 : unit = Obj.magic _1_inlined2 in + let _4 : unit = Obj.magic _4 in + let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in + let _1 : (Parsetree.expression) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in - let _v : (Parsetree.expression) = let _1 = + let _startpos = _startpos__1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _5 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined2_, _1_inlined4, _1_inlined3, _1_inlined2) in let _1 = - let op = - let _1 = -# 3753 "src/ocaml/preprocess/parser_raw.mly" - ("||") -# 11026 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 16358 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 16363 "src/ocaml/preprocess/parser_raw.ml" + + in -# 1017 "src/ocaml/preprocess/parser_raw.mly" - ( mkoperator ~loc:_sloc _1 ) -# 11034 "src/ocaml/preprocess/parser_raw.ml" +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 16369 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16380 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 16386 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2476 "src/ocaml/preprocess/parser_raw.mly" - ( mkinfix e1 op e2 ) -# 11040 "src/ocaml/preprocess/parser_raw.ml" +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 16406 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16412 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__5_ = _endpos_xs_ in + let _3 = + let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 11050 "src/ocaml/preprocess/parser_raw.ml" +# 1027 "src/ocaml/preprocess/parser_raw.mly" + ( mkrhs _1 _sloc ) +# 16424 "src/ocaml/preprocess/parser_raw.ml" in + let _endpos = _endpos__5_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2400 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 11056 "src/ocaml/preprocess/parser_raw.ml" +# 2520 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc (Pexp_setfield(_1, _3, _5)) ) +# 16433 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11065,66 +16442,92 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _1; MenhirLib.EngineTypes.startp = _startpos__1_; MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = i; + MenhirLib.EngineTypes.startp = _startpos_i_; + MenhirLib.EngineTypes.endp = _endpos_i_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = d; + MenhirLib.EngineTypes.startp = _startpos_d_; + MenhirLib.EngineTypes.endp = _endpos_d_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = array; + MenhirLib.EngineTypes.startp = _startpos_array_; + MenhirLib.EngineTypes.endp = _endpos_array_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in - let e1 : (Parsetree.expression) = Obj.magic e1 in + let _5 : unit = Obj.magic _5 in + let i : (Parsetree.expression) = Obj.magic i in + let _3 : unit = Obj.magic _3 in + let d : unit = Obj.magic d in + let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in + let _startpos = _startpos_array_ in + let _endpos = _endpos__1_inlined1_ in let _v : (Parsetree.expression) = let _1 = - let _1 = - let op = + let r = + let v = + let _1 = _1_inlined1 in let _1 = -# 3754 "src/ocaml/preprocess/parser_raw.mly" - ("&") -# 11098 "src/ocaml/preprocess/parser_raw.ml" +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16504 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in -# 1017 "src/ocaml/preprocess/parser_raw.mly" - ( mkoperator ~loc:_sloc _1 ) -# 11106 "src/ocaml/preprocess/parser_raw.ml" +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16509 "src/ocaml/preprocess/parser_raw.ml" in -# 2476 "src/ocaml/preprocess/parser_raw.mly" - ( mkinfix e1 op e2 ) -# 11112 "src/ocaml/preprocess/parser_raw.ml" +# 2521 "src/ocaml/preprocess/parser_raw.mly" + (Some v) +# 16515 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 11122 "src/ocaml/preprocess/parser_raw.ml" +# 2481 "src/ocaml/preprocess/parser_raw.mly" + ( array, d, Paren, i, r ) +# 16521 "src/ocaml/preprocess/parser_raw.ml" in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_array_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2400 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 11128 "src/ocaml/preprocess/parser_raw.ml" +# 2522 "src/ocaml/preprocess/parser_raw.mly" + ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 ) +# 16531 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11137,66 +16540,165 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = i; + MenhirLib.EngineTypes.startp = _startpos_i_; + MenhirLib.EngineTypes.endp = _endpos_i_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = d; + MenhirLib.EngineTypes.startp = _startpos_d_; + MenhirLib.EngineTypes.endp = _endpos_d_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = array; + MenhirLib.EngineTypes.startp = _startpos_array_; + MenhirLib.EngineTypes.endp = _endpos_array_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + }; + }; }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in - let e1 : (Parsetree.expression) = Obj.magic e1 in + let _5 : unit = Obj.magic _5 in + let i : (Parsetree.expression) = Obj.magic i in + let _3 : unit = Obj.magic _3 in + let d : unit = Obj.magic d in + let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in + let _startpos = _startpos_array_ in + let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = - let _1 = - let op = - let _1 = -# 3755 "src/ocaml/preprocess/parser_raw.mly" - ("&&") -# 11170 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in + let r = + let v = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 16626 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 16631 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 16637 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16648 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 16654 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 16674 "src/ocaml/preprocess/parser_raw.ml" + + in -# 1017 "src/ocaml/preprocess/parser_raw.mly" - ( mkoperator ~loc:_sloc _1 ) -# 11178 "src/ocaml/preprocess/parser_raw.ml" +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16680 "src/ocaml/preprocess/parser_raw.ml" in -# 2476 "src/ocaml/preprocess/parser_raw.mly" - ( mkinfix e1 op e2 ) -# 11184 "src/ocaml/preprocess/parser_raw.ml" +# 2521 "src/ocaml/preprocess/parser_raw.mly" + (Some v) +# 16686 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 11194 "src/ocaml/preprocess/parser_raw.ml" +# 2481 "src/ocaml/preprocess/parser_raw.mly" + ( array, d, Paren, i, r ) +# 16692 "src/ocaml/preprocess/parser_raw.ml" in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_array_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2400 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 11200 "src/ocaml/preprocess/parser_raw.ml" +# 2522 "src/ocaml/preprocess/parser_raw.mly" + ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 ) +# 16702 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11209,66 +16711,92 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e2; - MenhirLib.EngineTypes.startp = _startpos_e2_; - MenhirLib.EngineTypes.endp = _endpos_e2_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _1; MenhirLib.EngineTypes.startp = _startpos__1_; MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = e1; - MenhirLib.EngineTypes.startp = _startpos_e1_; - MenhirLib.EngineTypes.endp = _endpos_e1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = i; + MenhirLib.EngineTypes.startp = _startpos_i_; + MenhirLib.EngineTypes.endp = _endpos_i_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = d; + MenhirLib.EngineTypes.startp = _startpos_d_; + MenhirLib.EngineTypes.endp = _endpos_d_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = array; + MenhirLib.EngineTypes.startp = _startpos_array_; + MenhirLib.EngineTypes.endp = _endpos_array_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; }; }; } = _menhir_stack in - let e2 : (Parsetree.expression) = Obj.magic e2 in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in - let e1 : (Parsetree.expression) = Obj.magic e1 in + let _5 : unit = Obj.magic _5 in + let i : (Parsetree.expression) = Obj.magic i in + let _3 : unit = Obj.magic _3 in + let d : unit = Obj.magic d in + let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_e1_ in - let _endpos = _endpos_e2_ in + let _startpos = _startpos_array_ in + let _endpos = _endpos__1_inlined1_ in let _v : (Parsetree.expression) = let _1 = - let _1 = - let op = + let r = + let v = + let _1 = _1_inlined1 in let _1 = -# 3756 "src/ocaml/preprocess/parser_raw.mly" - (":=") -# 11242 "src/ocaml/preprocess/parser_raw.ml" +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16773 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in -# 1017 "src/ocaml/preprocess/parser_raw.mly" - ( mkoperator ~loc:_sloc _1 ) -# 11250 "src/ocaml/preprocess/parser_raw.ml" +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16778 "src/ocaml/preprocess/parser_raw.ml" in -# 2476 "src/ocaml/preprocess/parser_raw.mly" - ( mkinfix e1 op e2 ) -# 11256 "src/ocaml/preprocess/parser_raw.ml" +# 2521 "src/ocaml/preprocess/parser_raw.mly" + (Some v) +# 16784 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 11266 "src/ocaml/preprocess/parser_raw.ml" +# 2483 "src/ocaml/preprocess/parser_raw.mly" + ( array, d, Brace, i, r ) +# 16790 "src/ocaml/preprocess/parser_raw.ml" in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_array_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2400 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 11272 "src/ocaml/preprocess/parser_raw.ml" +# 2522 "src/ocaml/preprocess/parser_raw.mly" + ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 ) +# 16800 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11281,45 +16809,165 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = i; + MenhirLib.EngineTypes.startp = _startpos_i_; + MenhirLib.EngineTypes.endp = _endpos_i_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = d; + MenhirLib.EngineTypes.startp = _startpos_d_; + MenhirLib.EngineTypes.endp = _endpos_d_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = array; + MenhirLib.EngineTypes.startp = _startpos_array_; + MenhirLib.EngineTypes.endp = _endpos_array_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + }; + }; + }; }; } = _menhir_stack in - let _2 : (Parsetree.expression) = Obj.magic _2 in - let _1 : (string) = Obj.magic _1 in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _5 : unit = Obj.magic _5 in + let i : (Parsetree.expression) = Obj.magic i in + let _3 : unit = Obj.magic _3 in + let d : unit = Obj.magic d in + let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__2_ in + let _startpos = _startpos_array_ in + let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = - let _1 = - let _loc__1_ = (_startpos__1_, _endpos__1_) in + let r = + let v = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 16895 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 16900 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 16906 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16917 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 16923 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 16943 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 16949 "src/ocaml/preprocess/parser_raw.ml" + + in -# 2478 "src/ocaml/preprocess/parser_raw.mly" - ( mkuminus ~oploc:_loc__1_ _1 _2 ) -# 11307 "src/ocaml/preprocess/parser_raw.ml" +# 2521 "src/ocaml/preprocess/parser_raw.mly" + (Some v) +# 16955 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos__2_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 11317 "src/ocaml/preprocess/parser_raw.ml" +# 2483 "src/ocaml/preprocess/parser_raw.mly" + ( array, d, Brace, i, r ) +# 16961 "src/ocaml/preprocess/parser_raw.ml" in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_array_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 2400 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 11323 "src/ocaml/preprocess/parser_raw.ml" +# 2522 "src/ocaml/preprocess/parser_raw.mly" + ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 ) +# 16971 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11332,87 +16980,92 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _1; MenhirLib.EngineTypes.startp = _startpos__1_; MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = i; + MenhirLib.EngineTypes.startp = _startpos_i_; + MenhirLib.EngineTypes.endp = _endpos_i_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = d; + MenhirLib.EngineTypes.startp = _startpos_d_; + MenhirLib.EngineTypes.endp = _endpos_d_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = array; + MenhirLib.EngineTypes.startp = _startpos_array_; + MenhirLib.EngineTypes.endp = _endpos_array_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; }; } = _menhir_stack in - let _2 : (Parsetree.expression) = Obj.magic _2 in - let _1 : (string) = Obj.magic _1 in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _5 : unit = Obj.magic _5 in + let i : (Parsetree.expression) = Obj.magic i in + let _3 : unit = Obj.magic _3 in + let d : unit = Obj.magic d in + let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__2_ in + let _startpos = _startpos_array_ in + let _endpos = _endpos__1_inlined1_ in let _v : (Parsetree.expression) = let _1 = - let _1 = - let _loc__1_ = (_startpos__1_, _endpos__1_) in + let r = + let v = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 17042 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 17047 "src/ocaml/preprocess/parser_raw.ml" + + in -# 2480 "src/ocaml/preprocess/parser_raw.mly" - ( mkuplus ~oploc:_loc__1_ _1 _2 ) -# 11358 "src/ocaml/preprocess/parser_raw.ml" +# 2521 "src/ocaml/preprocess/parser_raw.mly" + (Some v) +# 17053 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos__2_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 11368 "src/ocaml/preprocess/parser_raw.ml" +# 2485 "src/ocaml/preprocess/parser_raw.mly" + ( array, d, Bracket, i, r ) +# 17059 "src/ocaml/preprocess/parser_raw.ml" in - -# 2400 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 11374 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - } = _menhir_stack in - let _3 : (Parsetree.expression) = Obj.magic _3 in - let _2 : unit = Obj.magic _2 in - let _1 : (Ast_helper.let_bindings) = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__3_ in - let _v : (Parsetree.expression) = let _endpos = _endpos__3_ in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_array_) in + let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2402 "src/ocaml/preprocess/parser_raw.mly" - ( expr_of_let_bindings ~loc:_sloc _1 (merloc _endpos__2_ _3) ) -# 11416 "src/ocaml/preprocess/parser_raw.ml" +# 2522 "src/ocaml/preprocess/parser_raw.mly" + ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 ) +# 17069 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11425,62 +17078,165 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = body; - MenhirLib.EngineTypes.startp = _startpos_body_; - MenhirLib.EngineTypes.endp = _endpos_body_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = bindings; - MenhirLib.EngineTypes.startp = _startpos_bindings_; - MenhirLib.EngineTypes.endp = _endpos_bindings_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = i; + MenhirLib.EngineTypes.startp = _startpos_i_; + MenhirLib.EngineTypes.endp = _endpos_i_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = d; + MenhirLib.EngineTypes.startp = _startpos_d_; + MenhirLib.EngineTypes.endp = _endpos_d_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = array; + MenhirLib.EngineTypes.startp = _startpos_array_; + MenhirLib.EngineTypes.endp = _endpos_array_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + }; }; }; }; } = _menhir_stack in - let body : (Parsetree.expression) = Obj.magic body in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _5 : unit = Obj.magic _5 in + let i : (Parsetree.expression) = Obj.magic i in let _3 : unit = Obj.magic _3 in - let bindings : (Parsetree.pattern * Parsetree.expression * Parsetree.binding_op list) = Obj.magic bindings in - let _1 : ( -# 775 "src/ocaml/preprocess/parser_raw.mly" - (string) -# 11458 "src/ocaml/preprocess/parser_raw.ml" - ) = Obj.magic _1 in + let d : unit = Obj.magic d in + let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos_body_ in - let _v : (Parsetree.expression) = let pbop_op = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in + let _startpos = _startpos_array_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression) = let _1 = + let r = + let v = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 17164 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 17169 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 17175 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 17186 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 17192 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 17212 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 17218 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2521 "src/ocaml/preprocess/parser_raw.mly" + (Some v) +# 17224 "src/ocaml/preprocess/parser_raw.ml" + + in -# 990 "src/ocaml/preprocess/parser_raw.mly" - ( mkrhs _1 _sloc ) -# 11470 "src/ocaml/preprocess/parser_raw.ml" +# 2485 "src/ocaml/preprocess/parser_raw.mly" + ( array, d, Bracket, i, r ) +# 17230 "src/ocaml/preprocess/parser_raw.ml" in - let _startpos_pbop_op_ = _startpos__1_ in - let _endpos = _endpos_body_ in - let _symbolstartpos = _startpos_pbop_op_ in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_array_) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2404 "src/ocaml/preprocess/parser_raw.mly" - ( let (pbop_pat, pbop_exp, rev_ands) = bindings in - let ands = List.rev rev_ands in - let pbop_loc = make_loc _sloc in - let let_ = {pbop_op; pbop_pat; pbop_exp; pbop_loc} in - mkexp ~loc:_sloc (Pexp_letop{ let_; ands; body}) ) -# 11484 "src/ocaml/preprocess/parser_raw.ml" +# 2522 "src/ocaml/preprocess/parser_raw.mly" + ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 ) +# 17240 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11493,37 +17249,113 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = es; + MenhirLib.EngineTypes.startp = _startpos_es_; + MenhirLib.EngineTypes.endp = _endpos_es_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = array; + MenhirLib.EngineTypes.startp = _startpos_array_; + MenhirLib.EngineTypes.endp = _endpos_array_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; }; }; } = _menhir_stack in - let _3 : (Parsetree.expression) = Obj.magic _3 in - let _2 : unit = Obj.magic _2 in - let _1 : (Parsetree.expression) = Obj.magic _1 in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _5 : unit = Obj.magic _5 in + let es : (Parsetree.expression list) = Obj.magic es in + let _3 : unit = Obj.magic _3 in + let _2 : ( +# 819 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 17302 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic _2 in + let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__3_ in - let _v : (Parsetree.expression) = let _endpos = _endpos__3_ in + let _startpos = _startpos_array_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression) = let _1 = + let r = + let v = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 17315 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 17320 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2523 "src/ocaml/preprocess/parser_raw.mly" + (Some v) +# 17326 "src/ocaml/preprocess/parser_raw.ml" + + in + let i = +# 2986 "src/ocaml/preprocess/parser_raw.mly" + ( es ) +# 17332 "src/ocaml/preprocess/parser_raw.ml" + in + let d = + let _1 = +# 124 "" + ( None ) +# 17338 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2497 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 17343 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2481 "src/ocaml/preprocess/parser_raw.mly" + ( array, d, Paren, i, r ) +# 17349 "src/ocaml/preprocess/parser_raw.ml" + + in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_array_) in + let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in - let _loc__2_ = (_startpos__2_, _endpos__2_) in let _sloc = (_symbolstartpos, _endpos) in -# 2410 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp_cons ~loc:_sloc _loc__2_ (ghexp ~loc:_sloc (Pexp_tuple[_1;(merloc _endpos__2_ _3)])) ) -# 11527 "src/ocaml/preprocess/parser_raw.ml" +# 2524 "src/ocaml/preprocess/parser_raw.mly" + ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) +# 17359 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11536,55 +17368,186 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = es; + MenhirLib.EngineTypes.startp = _startpos_es_; + MenhirLib.EngineTypes.endp = _endpos_es_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = array; + MenhirLib.EngineTypes.startp = _startpos_array_; + MenhirLib.EngineTypes.endp = _endpos_array_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + }; + }; }; }; } = _menhir_stack in - let _3 : (Parsetree.expression) = Obj.magic _3 in - let _2 : unit = Obj.magic _2 in - let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _5 : unit = Obj.magic _5 in + let es : (Parsetree.expression list) = Obj.magic es in + let _3 : unit = Obj.magic _3 in + let _2 : ( +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 11562 "src/ocaml/preprocess/parser_raw.ml" - ) = Obj.magic _1 in +# 17442 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic _2 in + let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__3_ in + let _startpos = _startpos_array_ in + let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = - let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 11571 "src/ocaml/preprocess/parser_raw.ml" + let r = + let v = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 17458 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 17463 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 17469 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 17480 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 17486 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 17506 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 17512 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2523 "src/ocaml/preprocess/parser_raw.mly" + (Some v) +# 17518 "src/ocaml/preprocess/parser_raw.ml" + + in + let i = +# 2986 "src/ocaml/preprocess/parser_raw.mly" + ( es ) +# 17524 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in + let d = + let _1 = +# 124 "" + ( None ) +# 17530 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2497 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 17535 "src/ocaml/preprocess/parser_raw.ml" + + in -# 990 "src/ocaml/preprocess/parser_raw.mly" - ( mkrhs _1 _sloc ) -# 11579 "src/ocaml/preprocess/parser_raw.ml" +# 2481 "src/ocaml/preprocess/parser_raw.mly" + ( array, d, Paren, i, r ) +# 17541 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos = _endpos__3_ in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_array_) in + let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2412 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc (Pexp_setinstvar(_1, _3)) ) -# 11588 "src/ocaml/preprocess/parser_raw.ml" +# 2524 "src/ocaml/preprocess/parser_raw.mly" + ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) +# 17551 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11597,61 +17560,136 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.semv = es; + MenhirLib.EngineTypes.startp = _startpos_es_; + MenhirLib.EngineTypes.endp = _endpos_es_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2_inlined1; + MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = array; + MenhirLib.EngineTypes.startp = _startpos_array_; + MenhirLib.EngineTypes.endp = _endpos_array_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; }; }; }; }; } = _menhir_stack in - let _5 : (Parsetree.expression) = Obj.magic _5 in - let _4 : unit = Obj.magic _4 in - let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in - let _2 : unit = Obj.magic _2 in - let _1 : (Parsetree.expression) = Obj.magic _1 in + let _1_inlined2 : (Parsetree.expression) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _5 : unit = Obj.magic _5 in + let es : (Parsetree.expression list) = Obj.magic es in + let _3 : unit = Obj.magic _3 in + let _2 : ( +# 819 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 17625 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic _2 in + let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in + let _1 : unit = Obj.magic _1 in + let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__5_ in - let _v : (Parsetree.expression) = let _3 = - let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in + let _startpos = _startpos_array_ in + let _endpos = _endpos__1_inlined2_ in + let _v : (Parsetree.expression) = let _1 = + let r = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let v = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 17641 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 17646 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2523 "src/ocaml/preprocess/parser_raw.mly" + (Some v) +# 17652 "src/ocaml/preprocess/parser_raw.ml" + + in + let i = +# 2986 "src/ocaml/preprocess/parser_raw.mly" + ( es ) +# 17658 "src/ocaml/preprocess/parser_raw.ml" + in + let d = + let _1 = + let _2 = _2_inlined1 in + let x = +# 2497 "src/ocaml/preprocess/parser_raw.mly" + (_2) +# 17666 "src/ocaml/preprocess/parser_raw.ml" + in + +# 126 "" + ( Some x ) +# 17671 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2497 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 17677 "src/ocaml/preprocess/parser_raw.ml" + + in -# 990 "src/ocaml/preprocess/parser_raw.mly" - ( mkrhs _1 _sloc ) -# 11646 "src/ocaml/preprocess/parser_raw.ml" +# 2481 "src/ocaml/preprocess/parser_raw.mly" + ( array, d, Paren, i, r ) +# 17683 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos = _endpos__5_ in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined2_, _startpos_array_) in + let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2414 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc (Pexp_setfield(_1, _3, _5)) ) -# 11655 "src/ocaml/preprocess/parser_raw.ml" +# 2524 "src/ocaml/preprocess/parser_raw.mly" + ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) +# 17693 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11664,40 +17702,70 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = v; - MenhirLib.EngineTypes.startp = _startpos_v_; - MenhirLib.EngineTypes.endp = _endpos_v_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _1_inlined4; + MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = i; - MenhirLib.EngineTypes.startp = _startpos_i_; - MenhirLib.EngineTypes.endp = _endpos_i_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = d; - MenhirLib.EngineTypes.startp = _startpos_d_; - MenhirLib.EngineTypes.endp = _endpos_d_; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = array; - MenhirLib.EngineTypes.startp = _startpos_array_; - MenhirLib.EngineTypes.endp = _endpos_array_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = es; + MenhirLib.EngineTypes.startp = _startpos_es_; + MenhirLib.EngineTypes.endp = _endpos_es_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2_inlined1; + MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = array; + MenhirLib.EngineTypes.startp = _startpos_array_; + MenhirLib.EngineTypes.endp = _endpos_array_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; }; }; }; @@ -11705,36 +17773,138 @@ module Tables = struct }; }; } = _menhir_stack in - let v : (Parsetree.expression) = Obj.magic v in - let _1 : unit = Obj.magic _1 in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in + let _1_inlined3 : (string Location.loc option) = Obj.magic _1_inlined3 in + let _1_inlined2 : unit = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in let _5 : unit = Obj.magic _5 in - let i : (Parsetree.expression) = Obj.magic i in + let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in - let d : unit = Obj.magic d in + let _2 : ( +# 819 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 17788 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic _2 in + let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in + let _1 : unit = Obj.magic _1 in let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_array_ in - let _endpos = _endpos_v_ in + let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = - let r = -# 2415 "src/ocaml/preprocess/parser_raw.mly" - (Some v) -# 11723 "src/ocaml/preprocess/parser_raw.ml" + let r = + let (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined2_, _1_inlined4, _1_inlined3, _1_inlined2, _1_inlined1) in + let v = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 17807 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 17812 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 17818 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 17829 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 17835 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 17855 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 17861 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2523 "src/ocaml/preprocess/parser_raw.mly" + (Some v) +# 17867 "src/ocaml/preprocess/parser_raw.ml" + + in + let i = +# 2986 "src/ocaml/preprocess/parser_raw.mly" + ( es ) +# 17873 "src/ocaml/preprocess/parser_raw.ml" in + let d = + let _1 = + let _2 = _2_inlined1 in + let x = +# 2497 "src/ocaml/preprocess/parser_raw.mly" + (_2) +# 17881 "src/ocaml/preprocess/parser_raw.ml" + in + +# 126 "" + ( Some x ) +# 17886 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2497 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 17892 "src/ocaml/preprocess/parser_raw.ml" + + in -# 2375 "src/ocaml/preprocess/parser_raw.mly" +# 2481 "src/ocaml/preprocess/parser_raw.mly" ( array, d, Paren, i, r ) -# 11728 "src/ocaml/preprocess/parser_raw.ml" +# 17898 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_array_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2416 "src/ocaml/preprocess/parser_raw.mly" - ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 ) -# 11738 "src/ocaml/preprocess/parser_raw.ml" +# 2524 "src/ocaml/preprocess/parser_raw.mly" + ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) +# 17908 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11747,9 +17917,9 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = v; - MenhirLib.EngineTypes.startp = _startpos_v_; - MenhirLib.EngineTypes.endp = _endpos_v_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _1; @@ -11762,9 +17932,9 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = i; - MenhirLib.EngineTypes.startp = _startpos_i_; - MenhirLib.EngineTypes.endp = _endpos_i_; + MenhirLib.EngineTypes.semv = es; + MenhirLib.EngineTypes.startp = _startpos_es_; + MenhirLib.EngineTypes.endp = _endpos_es_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _3; @@ -11772,9 +17942,9 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = d; - MenhirLib.EngineTypes.startp = _startpos_d_; - MenhirLib.EngineTypes.endp = _endpos_d_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _menhir_s; MenhirLib.EngineTypes.semv = array; @@ -11788,36 +17958,72 @@ module Tables = struct }; }; } = _menhir_stack in - let v : (Parsetree.expression) = Obj.magic v in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _5 : unit = Obj.magic _5 in - let i : (Parsetree.expression) = Obj.magic i in + let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in - let d : unit = Obj.magic d in + let _2 : ( +# 819 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 17970 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic _2 in let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_array_ in - let _endpos = _endpos_v_ in + let _endpos = _endpos__1_inlined1_ in let _v : (Parsetree.expression) = let _1 = - let r = -# 2415 "src/ocaml/preprocess/parser_raw.mly" - (Some v) -# 11806 "src/ocaml/preprocess/parser_raw.ml" + let r = + let v = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 17983 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 17988 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2523 "src/ocaml/preprocess/parser_raw.mly" + (Some v) +# 17994 "src/ocaml/preprocess/parser_raw.ml" + + in + let i = +# 2986 "src/ocaml/preprocess/parser_raw.mly" + ( es ) +# 18000 "src/ocaml/preprocess/parser_raw.ml" in + let d = + let _1 = +# 124 "" + ( None ) +# 18006 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2497 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 18011 "src/ocaml/preprocess/parser_raw.ml" + + in -# 2377 "src/ocaml/preprocess/parser_raw.mly" +# 2483 "src/ocaml/preprocess/parser_raw.mly" ( array, d, Brace, i, r ) -# 11811 "src/ocaml/preprocess/parser_raw.ml" +# 18017 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_array_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2416 "src/ocaml/preprocess/parser_raw.mly" - ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 ) -# 11821 "src/ocaml/preprocess/parser_raw.ml" +# 2524 "src/ocaml/preprocess/parser_raw.mly" + ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) +# 18027 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11830,40 +18036,58 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = v; - MenhirLib.EngineTypes.startp = _startpos_v_; - MenhirLib.EngineTypes.endp = _endpos_v_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = i; - MenhirLib.EngineTypes.startp = _startpos_i_; - MenhirLib.EngineTypes.endp = _endpos_i_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = d; - MenhirLib.EngineTypes.startp = _startpos_d_; - MenhirLib.EngineTypes.endp = _endpos_d_; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = array; - MenhirLib.EngineTypes.startp = _startpos_array_; - MenhirLib.EngineTypes.endp = _endpos_array_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = es; + MenhirLib.EngineTypes.startp = _startpos_es_; + MenhirLib.EngineTypes.endp = _endpos_es_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = array; + MenhirLib.EngineTypes.startp = _startpos_array_; + MenhirLib.EngineTypes.endp = _endpos_array_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; }; }; }; @@ -11871,36 +18095,127 @@ module Tables = struct }; }; } = _menhir_stack in - let v : (Parsetree.expression) = Obj.magic v in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _5 : unit = Obj.magic _5 in - let i : (Parsetree.expression) = Obj.magic i in + let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in - let d : unit = Obj.magic d in + let _2 : ( +# 819 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 18110 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic _2 in let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_array_ in - let _endpos = _endpos_v_ in + let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = - let r = -# 2415 "src/ocaml/preprocess/parser_raw.mly" - (Some v) -# 11889 "src/ocaml/preprocess/parser_raw.ml" + let r = + let v = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 18126 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 18131 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 18137 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 18148 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 18154 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 18174 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 18180 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2523 "src/ocaml/preprocess/parser_raw.mly" + (Some v) +# 18186 "src/ocaml/preprocess/parser_raw.ml" + + in + let i = +# 2986 "src/ocaml/preprocess/parser_raw.mly" + ( es ) +# 18192 "src/ocaml/preprocess/parser_raw.ml" in + let d = + let _1 = +# 124 "" + ( None ) +# 18198 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2497 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 18203 "src/ocaml/preprocess/parser_raw.ml" + + in -# 2379 "src/ocaml/preprocess/parser_raw.mly" - ( array, d, Bracket, i, r ) -# 11894 "src/ocaml/preprocess/parser_raw.ml" +# 2483 "src/ocaml/preprocess/parser_raw.mly" + ( array, d, Brace, i, r ) +# 18209 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_array_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2416 "src/ocaml/preprocess/parser_raw.mly" - ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 ) -# 11904 "src/ocaml/preprocess/parser_raw.ml" +# 2524 "src/ocaml/preprocess/parser_raw.mly" + ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) +# 18219 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -11913,14 +18228,14 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = v; - MenhirLib.EngineTypes.startp = _startpos_v_; - MenhirLib.EngineTypes.endp = _endpos_v_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _5; @@ -11942,11 +18257,23 @@ module Tables = struct MenhirLib.EngineTypes.startp = _startpos__2_; MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = array; - MenhirLib.EngineTypes.startp = _startpos_array_; - MenhirLib.EngineTypes.endp = _endpos_array_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2_inlined1; + MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = array; + MenhirLib.EngineTypes.startp = _startpos_array_; + MenhirLib.EngineTypes.endp = _endpos_array_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; }; }; }; @@ -11954,57 +18281,83 @@ module Tables = struct }; }; } = _menhir_stack in - let v : (Parsetree.expression) = Obj.magic v in - let _1 : unit = Obj.magic _1 in + let _1_inlined2 : (Parsetree.expression) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in let _5 : unit = Obj.magic _5 in let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 11966 "src/ocaml/preprocess/parser_raw.ml" +# 18293 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _2 in + let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in + let _1 : unit = Obj.magic _1 in let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_array_ in - let _endpos = _endpos_v_ in + let _endpos = _endpos__1_inlined2_ in let _v : (Parsetree.expression) = let _1 = - let r = -# 2417 "src/ocaml/preprocess/parser_raw.mly" + let r = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let v = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 18309 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 18314 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2523 "src/ocaml/preprocess/parser_raw.mly" (Some v) -# 11976 "src/ocaml/preprocess/parser_raw.ml" - in +# 18320 "src/ocaml/preprocess/parser_raw.ml" + + in let i = -# 2846 "src/ocaml/preprocess/parser_raw.mly" +# 2986 "src/ocaml/preprocess/parser_raw.mly" ( es ) -# 11981 "src/ocaml/preprocess/parser_raw.ml" +# 18326 "src/ocaml/preprocess/parser_raw.ml" in let d = - let _1 = -# 124 "" - ( None ) -# 11987 "src/ocaml/preprocess/parser_raw.ml" - in + let _1 = + let _2 = _2_inlined1 in + let x = +# 2497 "src/ocaml/preprocess/parser_raw.mly" + (_2) +# 18334 "src/ocaml/preprocess/parser_raw.ml" + in + +# 126 "" + ( Some x ) +# 18339 "src/ocaml/preprocess/parser_raw.ml" + + in -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 11992 "src/ocaml/preprocess/parser_raw.ml" +# 18345 "src/ocaml/preprocess/parser_raw.ml" in -# 2375 "src/ocaml/preprocess/parser_raw.mly" - ( array, d, Paren, i, r ) -# 11998 "src/ocaml/preprocess/parser_raw.ml" +# 2483 "src/ocaml/preprocess/parser_raw.mly" + ( array, d, Brace, i, r ) +# 18351 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined2_, _startpos_array_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2418 "src/ocaml/preprocess/parser_raw.mly" +# 2524 "src/ocaml/preprocess/parser_raw.mly" ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) -# 12008 "src/ocaml/preprocess/parser_raw.ml" +# 18361 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12017,50 +18370,68 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = v; - MenhirLib.EngineTypes.startp = _startpos_v_; - MenhirLib.EngineTypes.endp = _endpos_v_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.semv = _1_inlined4; + MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = es; - MenhirLib.EngineTypes.startp = _startpos_es_; - MenhirLib.EngineTypes.endp = _endpos_es_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2_inlined1; - MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; + MenhirLib.EngineTypes.semv = es; + MenhirLib.EngineTypes.startp = _startpos_es_; + MenhirLib.EngineTypes.endp = _endpos_es_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = array; - MenhirLib.EngineTypes.startp = _startpos_array_; - MenhirLib.EngineTypes.endp = _endpos_array_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2_inlined1; + MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = array; + MenhirLib.EngineTypes.startp = _startpos_array_; + MenhirLib.EngineTypes.endp = _endpos_array_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; }; }; }; @@ -12070,70 +18441,138 @@ module Tables = struct }; }; } = _menhir_stack in - let v : (Parsetree.expression) = Obj.magic v in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in + let _1_inlined3 : (string Location.loc option) = Obj.magic _1_inlined3 in + let _1_inlined2 : unit = Obj.magic _1_inlined2 in let _1_inlined1 : unit = Obj.magic _1_inlined1 in let _5 : unit = Obj.magic _5 in let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 12082 "src/ocaml/preprocess/parser_raw.ml" +# 18456 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _2 in let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in let _1 : unit = Obj.magic _1 in let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_array_ in - let _endpos = _endpos_v_ in + let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = let r = - let _1 = _1_inlined1 in + let (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined2_, _1_inlined4, _1_inlined3, _1_inlined2, _1_inlined1) in + let v = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 18475 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 18480 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 18486 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 18497 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 18503 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 18523 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 18529 "src/ocaml/preprocess/parser_raw.ml" + + in -# 2417 "src/ocaml/preprocess/parser_raw.mly" +# 2523 "src/ocaml/preprocess/parser_raw.mly" (Some v) -# 12096 "src/ocaml/preprocess/parser_raw.ml" +# 18535 "src/ocaml/preprocess/parser_raw.ml" in let i = -# 2846 "src/ocaml/preprocess/parser_raw.mly" +# 2986 "src/ocaml/preprocess/parser_raw.mly" ( es ) -# 12102 "src/ocaml/preprocess/parser_raw.ml" +# 18541 "src/ocaml/preprocess/parser_raw.ml" in let d = let _1 = let _2 = _2_inlined1 in let x = -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" (_2) -# 12110 "src/ocaml/preprocess/parser_raw.ml" +# 18549 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 12115 "src/ocaml/preprocess/parser_raw.ml" +# 18554 "src/ocaml/preprocess/parser_raw.ml" in -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 12121 "src/ocaml/preprocess/parser_raw.ml" +# 18560 "src/ocaml/preprocess/parser_raw.ml" in -# 2375 "src/ocaml/preprocess/parser_raw.mly" - ( array, d, Paren, i, r ) -# 12127 "src/ocaml/preprocess/parser_raw.ml" +# 2483 "src/ocaml/preprocess/parser_raw.mly" + ( array, d, Brace, i, r ) +# 18566 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_array_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2418 "src/ocaml/preprocess/parser_raw.mly" +# 2524 "src/ocaml/preprocess/parser_raw.mly" ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) -# 12137 "src/ocaml/preprocess/parser_raw.ml" +# 18576 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12146,9 +18585,9 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = v; - MenhirLib.EngineTypes.startp = _startpos_v_; - MenhirLib.EngineTypes.endp = _endpos_v_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _1; @@ -12187,57 +18626,72 @@ module Tables = struct }; }; } = _menhir_stack in - let v : (Parsetree.expression) = Obj.magic v in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _5 : unit = Obj.magic _5 in let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 12199 "src/ocaml/preprocess/parser_raw.ml" +# 18638 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _2 in let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_array_ in - let _endpos = _endpos_v_ in + let _endpos = _endpos__1_inlined1_ in let _v : (Parsetree.expression) = let _1 = - let r = -# 2417 "src/ocaml/preprocess/parser_raw.mly" + let r = + let v = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 18651 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 18656 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2523 "src/ocaml/preprocess/parser_raw.mly" (Some v) -# 12209 "src/ocaml/preprocess/parser_raw.ml" - in +# 18662 "src/ocaml/preprocess/parser_raw.ml" + + in let i = -# 2846 "src/ocaml/preprocess/parser_raw.mly" +# 2986 "src/ocaml/preprocess/parser_raw.mly" ( es ) -# 12214 "src/ocaml/preprocess/parser_raw.ml" +# 18668 "src/ocaml/preprocess/parser_raw.ml" in let d = let _1 = # 124 "" ( None ) -# 12220 "src/ocaml/preprocess/parser_raw.ml" +# 18674 "src/ocaml/preprocess/parser_raw.ml" in -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 12225 "src/ocaml/preprocess/parser_raw.ml" +# 18679 "src/ocaml/preprocess/parser_raw.ml" in -# 2377 "src/ocaml/preprocess/parser_raw.mly" - ( array, d, Brace, i, r ) -# 12231 "src/ocaml/preprocess/parser_raw.ml" +# 2485 "src/ocaml/preprocess/parser_raw.mly" + ( array, d, Bracket, i, r ) +# 18685 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined1_, _startpos_array_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2418 "src/ocaml/preprocess/parser_raw.mly" +# 2524 "src/ocaml/preprocess/parser_raw.mly" ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) -# 12241 "src/ocaml/preprocess/parser_raw.ml" +# 18695 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12250,50 +18704,56 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = v; - MenhirLib.EngineTypes.startp = _startpos_v_; - MenhirLib.EngineTypes.endp = _endpos_v_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = es; - MenhirLib.EngineTypes.startp = _startpos_es_; - MenhirLib.EngineTypes.endp = _endpos_es_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2_inlined1; - MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; + MenhirLib.EngineTypes.semv = es; + MenhirLib.EngineTypes.startp = _startpos_es_; + MenhirLib.EngineTypes.endp = _endpos_es_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = array; - MenhirLib.EngineTypes.startp = _startpos_array_; - MenhirLib.EngineTypes.endp = _endpos_array_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = array; + MenhirLib.EngineTypes.startp = _startpos_array_; + MenhirLib.EngineTypes.endp = _endpos_array_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; }; }; }; @@ -12303,70 +18763,127 @@ module Tables = struct }; }; } = _menhir_stack in - let v : (Parsetree.expression) = Obj.magic v in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in let _5 : unit = Obj.magic _5 in let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 12315 "src/ocaml/preprocess/parser_raw.ml" +# 18778 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _2 in - let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in - let _1 : unit = Obj.magic _1 in let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_array_ in - let _endpos = _endpos_v_ in + let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = let r = - let _1 = _1_inlined1 in + let v = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 18794 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 18799 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 18805 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 18816 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 18822 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 18842 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 18848 "src/ocaml/preprocess/parser_raw.ml" + + in -# 2417 "src/ocaml/preprocess/parser_raw.mly" +# 2523 "src/ocaml/preprocess/parser_raw.mly" (Some v) -# 12329 "src/ocaml/preprocess/parser_raw.ml" +# 18854 "src/ocaml/preprocess/parser_raw.ml" in let i = -# 2846 "src/ocaml/preprocess/parser_raw.mly" +# 2986 "src/ocaml/preprocess/parser_raw.mly" ( es ) -# 12335 "src/ocaml/preprocess/parser_raw.ml" +# 18860 "src/ocaml/preprocess/parser_raw.ml" in let d = - let _1 = - let _2 = _2_inlined1 in - let x = -# 2391 "src/ocaml/preprocess/parser_raw.mly" - (_2) -# 12343 "src/ocaml/preprocess/parser_raw.ml" - in - -# 126 "" - ( Some x ) -# 12348 "src/ocaml/preprocess/parser_raw.ml" - - in + let _1 = +# 124 "" + ( None ) +# 18866 "src/ocaml/preprocess/parser_raw.ml" + in -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 12354 "src/ocaml/preprocess/parser_raw.ml" +# 18871 "src/ocaml/preprocess/parser_raw.ml" in -# 2377 "src/ocaml/preprocess/parser_raw.mly" - ( array, d, Brace, i, r ) -# 12360 "src/ocaml/preprocess/parser_raw.ml" +# 2485 "src/ocaml/preprocess/parser_raw.mly" + ( array, d, Bracket, i, r ) +# 18877 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_array_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2418 "src/ocaml/preprocess/parser_raw.mly" +# 2524 "src/ocaml/preprocess/parser_raw.mly" ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) -# 12370 "src/ocaml/preprocess/parser_raw.ml" +# 18887 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12379,14 +18896,14 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = v; - MenhirLib.EngineTypes.startp = _startpos_v_; - MenhirLib.EngineTypes.endp = _endpos_v_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _5; @@ -12408,11 +18925,23 @@ module Tables = struct MenhirLib.EngineTypes.startp = _startpos__2_; MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = array; - MenhirLib.EngineTypes.startp = _startpos_array_; - MenhirLib.EngineTypes.endp = _endpos_array_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2_inlined1; + MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = array; + MenhirLib.EngineTypes.startp = _startpos_array_; + MenhirLib.EngineTypes.endp = _endpos_array_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; }; }; }; @@ -12420,57 +18949,83 @@ module Tables = struct }; }; } = _menhir_stack in - let v : (Parsetree.expression) = Obj.magic v in - let _1 : unit = Obj.magic _1 in + let _1_inlined2 : (Parsetree.expression) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in let _5 : unit = Obj.magic _5 in let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 12432 "src/ocaml/preprocess/parser_raw.ml" +# 18961 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _2 in + let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in + let _1 : unit = Obj.magic _1 in let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_array_ in - let _endpos = _endpos_v_ in + let _endpos = _endpos__1_inlined2_ in let _v : (Parsetree.expression) = let _1 = - let r = -# 2417 "src/ocaml/preprocess/parser_raw.mly" + let r = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let v = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 18977 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 18982 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2523 "src/ocaml/preprocess/parser_raw.mly" (Some v) -# 12442 "src/ocaml/preprocess/parser_raw.ml" - in +# 18988 "src/ocaml/preprocess/parser_raw.ml" + + in let i = -# 2846 "src/ocaml/preprocess/parser_raw.mly" +# 2986 "src/ocaml/preprocess/parser_raw.mly" ( es ) -# 12447 "src/ocaml/preprocess/parser_raw.ml" +# 18994 "src/ocaml/preprocess/parser_raw.ml" in let d = - let _1 = -# 124 "" - ( None ) -# 12453 "src/ocaml/preprocess/parser_raw.ml" - in + let _1 = + let _2 = _2_inlined1 in + let x = +# 2497 "src/ocaml/preprocess/parser_raw.mly" + (_2) +# 19002 "src/ocaml/preprocess/parser_raw.ml" + in + +# 126 "" + ( Some x ) +# 19007 "src/ocaml/preprocess/parser_raw.ml" + + in -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 12458 "src/ocaml/preprocess/parser_raw.ml" +# 19013 "src/ocaml/preprocess/parser_raw.ml" in -# 2379 "src/ocaml/preprocess/parser_raw.mly" +# 2485 "src/ocaml/preprocess/parser_raw.mly" ( array, d, Bracket, i, r ) -# 12464 "src/ocaml/preprocess/parser_raw.ml" +# 19019 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in + let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined2_, _startpos_array_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2418 "src/ocaml/preprocess/parser_raw.mly" +# 2524 "src/ocaml/preprocess/parser_raw.mly" ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) -# 12474 "src/ocaml/preprocess/parser_raw.ml" +# 19029 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12483,50 +19038,68 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = v; - MenhirLib.EngineTypes.startp = _startpos_v_; - MenhirLib.EngineTypes.endp = _endpos_v_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.semv = _1_inlined4; + MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = es; - MenhirLib.EngineTypes.startp = _startpos_es_; - MenhirLib.EngineTypes.endp = _endpos_es_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2_inlined1; - MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; + MenhirLib.EngineTypes.semv = es; + MenhirLib.EngineTypes.startp = _startpos_es_; + MenhirLib.EngineTypes.endp = _endpos_es_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = array; - MenhirLib.EngineTypes.startp = _startpos_array_; - MenhirLib.EngineTypes.endp = _endpos_array_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2_inlined1; + MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = array; + MenhirLib.EngineTypes.startp = _startpos_array_; + MenhirLib.EngineTypes.endp = _endpos_array_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; }; }; }; @@ -12536,70 +19109,138 @@ module Tables = struct }; }; } = _menhir_stack in - let v : (Parsetree.expression) = Obj.magic v in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in + let _1_inlined3 : (string Location.loc option) = Obj.magic _1_inlined3 in + let _1_inlined2 : unit = Obj.magic _1_inlined2 in let _1_inlined1 : unit = Obj.magic _1_inlined1 in let _5 : unit = Obj.magic _5 in let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 12548 "src/ocaml/preprocess/parser_raw.ml" +# 19124 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _2 in let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in let _1 : unit = Obj.magic _1 in let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_array_ in - let _endpos = _endpos_v_ in + let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = let r = - let _1 = _1_inlined1 in + let (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined2_, _1_inlined4, _1_inlined3, _1_inlined2, _1_inlined1) in + let v = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 19143 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 19148 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 19154 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 19165 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 19171 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 19191 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 19197 "src/ocaml/preprocess/parser_raw.ml" + + in -# 2417 "src/ocaml/preprocess/parser_raw.mly" +# 2523 "src/ocaml/preprocess/parser_raw.mly" (Some v) -# 12562 "src/ocaml/preprocess/parser_raw.ml" +# 19203 "src/ocaml/preprocess/parser_raw.ml" in let i = -# 2846 "src/ocaml/preprocess/parser_raw.mly" +# 2986 "src/ocaml/preprocess/parser_raw.mly" ( es ) -# 12568 "src/ocaml/preprocess/parser_raw.ml" +# 19209 "src/ocaml/preprocess/parser_raw.ml" in let d = let _1 = let _2 = _2_inlined1 in let x = -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" (_2) -# 12576 "src/ocaml/preprocess/parser_raw.ml" +# 19217 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 12581 "src/ocaml/preprocess/parser_raw.ml" +# 19222 "src/ocaml/preprocess/parser_raw.ml" in -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 12587 "src/ocaml/preprocess/parser_raw.ml" +# 19228 "src/ocaml/preprocess/parser_raw.ml" in -# 2379 "src/ocaml/preprocess/parser_raw.mly" +# 2485 "src/ocaml/preprocess/parser_raw.mly" ( array, d, Bracket, i, r ) -# 12593 "src/ocaml/preprocess/parser_raw.ml" +# 19234 "src/ocaml/preprocess/parser_raw.ml" in - let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in + let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_array_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2418 "src/ocaml/preprocess/parser_raw.mly" +# 2524 "src/ocaml/preprocess/parser_raw.mly" ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) -# 12603 "src/ocaml/preprocess/parser_raw.ml" +# 19244 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12629,59 +19270,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.expression) = -# 2420 "src/ocaml/preprocess/parser_raw.mly" +# 2526 "src/ocaml/preprocess/parser_raw.mly" ( Exp.attr _1 _2 ) -# 12635 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let _menhir_s = _menhir_env.MenhirLib.EngineTypes.current in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in - let _endpos = _startpos in - let _v : (string Location.loc option) = -# 4034 "src/ocaml/preprocess/parser_raw.mly" - ( None ) -# 12653 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - } = _menhir_stack in - let _2 : (string Location.loc) = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__2_ in - let _v : (string Location.loc option) = -# 4035 "src/ocaml/preprocess/parser_raw.mly" - ( Some _2 ) -# 12685 "src/ocaml/preprocess/parser_raw.ml" +# 19276 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12699,9 +19290,9 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _2; @@ -12718,16 +19309,36 @@ module Tables = struct }; } = _menhir_stack in let _4 : unit = Obj.magic _4 in - let _3 : (Parsetree.payload) = Obj.magic _3 in - let _2 : (string Location.loc) = Obj.magic _2 in + let xs : (string Location.loc list) = Obj.magic xs in + let _2 : unit = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in - let _v : (Parsetree.extension) = -# 4047 "src/ocaml/preprocess/parser_raw.mly" - ( (_2, _3) ) -# 12731 "src/ocaml/preprocess/parser_raw.ml" + let _v : (Parsetree.function_param list) = let ty_params = +# 2774 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 19322 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos = _endpos__4_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2923 "src/ocaml/preprocess/parser_raw.mly" + ( (* We desugar (type a b c) to (type a) (type b) (type c). + If we do this desugaring, the loc for each parameter is a ghost. + *) + let loc = + match ty_params with + | [] -> assert false (* lident_list is non-empty *) + | [_] -> make_loc _sloc + | _ :: _ :: _ -> ghost_loc _sloc + in + List.map + (fun x -> { pparam_loc = loc; pparam_desc = Pparam_newtype x }) + ty_params + ) +# 19342 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12745,195 +19356,19 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let _1 : ( -# 833 "src/ocaml/preprocess/parser_raw.mly" - (string * Location.t * string * Location.t * string option) -# 12752 "src/ocaml/preprocess/parser_raw.ml" - ) = Obj.magic _1 in + let _1 : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in - let _v : (Parsetree.extension) = let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 4049 "src/ocaml/preprocess/parser_raw.mly" - ( mk_quotedext ~loc:_sloc _1 ) -# 12763 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined3; - MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - }; - } = _menhir_stack in - let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in - let _1_inlined2 : (Longident.t) = Obj.magic _1_inlined2 in - let _3 : unit = Obj.magic _3 in - let _1_inlined1 : (string) = Obj.magic _1_inlined1 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__1_inlined3_ in - let _v : (Parsetree.extension_constructor) = let attrs = - let _1 = _1_inlined3 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 12818 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos_attrs_ = _endpos__1_inlined3_ in - let lid = - let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 990 "src/ocaml/preprocess/parser_raw.mly" - ( mkrhs _1 _sloc ) -# 12830 "src/ocaml/preprocess/parser_raw.ml" - - in - let cid = - let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 990 "src/ocaml/preprocess/parser_raw.mly" - ( mkrhs _1 _sloc ) -# 12841 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos = _endpos_attrs_ in + let _v : (Parsetree.function_param list) = let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3391 "src/ocaml/preprocess/parser_raw.mly" - ( let info = symbol_info _endpos in - Te.rebind cid lid ~attrs ~loc:(make_loc _sloc) ~info ) -# 12851 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - } = _menhir_stack in - let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in - let _3 : unit = Obj.magic _3 in - let _1 : (string) = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__1_inlined2_ in - let _v : (Parsetree.extension_constructor) = let attrs = - let _1 = _1_inlined2 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 12899 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos_attrs_ = _endpos__1_inlined2_ in - let lid = - let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 990 "src/ocaml/preprocess/parser_raw.mly" - ( mkrhs _1 _sloc ) -# 12911 "src/ocaml/preprocess/parser_raw.ml" - - in - let cid = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 990 "src/ocaml/preprocess/parser_raw.mly" - ( mkrhs _1 _sloc ) -# 12921 "src/ocaml/preprocess/parser_raw.ml" - - in - let _startpos_cid_ = _startpos__1_ in - let _1 = -# 3852 "src/ocaml/preprocess/parser_raw.mly" - ( () ) -# 12928 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos = _endpos_attrs_ in - let _symbolstartpos = _startpos_cid_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 3391 "src/ocaml/preprocess/parser_raw.mly" - ( let info = symbol_info _endpos in - Te.rebind cid lid ~attrs ~loc:(make_loc _sloc) ~info ) -# 12937 "src/ocaml/preprocess/parser_raw.ml" +# 2937 "src/ocaml/preprocess/parser_raw.mly" + ( let a, b, c = _1 in + [ { pparam_loc = make_loc _sloc; pparam_desc = Pparam_val (a, b, c) } ] + ) +# 19372 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -12945,126 +19380,32 @@ module Tables = struct (fun _menhir_env -> let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - } = _menhir_stack in - let _4 : unit = Obj.magic _4 in - let _3 : (Parsetree.payload) = Obj.magic _3 in - let _2 : (string Location.loc) = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__4_ in - let _v : (Parsetree.attribute) = let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 4022 "src/ocaml/preprocess/parser_raw.mly" - ( mark_symbol_docs _sloc; - Attr.mk ~loc:(make_loc _sloc) _2 _3 ) -# 12987 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let _menhir_s = _menhir_env.MenhirLib.EngineTypes.current in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in - let _endpos = _startpos in - let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = let params = -# 2168 "src/ocaml/preprocess/parser_raw.mly" - ( [] ) -# 13005 "src/ocaml/preprocess/parser_raw.ml" - in - -# 1985 "src/ocaml/preprocess/parser_raw.mly" - ( params ) -# 13010 "src/ocaml/preprocess/parser_raw.ml" - in - { MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = xs; - MenhirLib.EngineTypes.startp = _startpos_xs_; - MenhirLib.EngineTypes.endp = _endpos_xs_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; } = _menhir_stack in - let _3 : unit = Obj.magic _3 in - let xs : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic xs in - let _1 : unit = Obj.magic _1 in + let xs : (Parsetree.function_param list) = Obj.magic xs in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__3_ in - let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = let params = - let params = - let xs = + let _startpos = _startpos_xs_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.function_param list) = let _1 = + let xs = # 253 "" ( List.rev xs ) -# 13051 "src/ocaml/preprocess/parser_raw.ml" - in - -# 1124 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 13056 "src/ocaml/preprocess/parser_raw.ml" - - in +# 19398 "src/ocaml/preprocess/parser_raw.ml" + in -# 2170 "src/ocaml/preprocess/parser_raw.mly" - ( params ) -# 13062 "src/ocaml/preprocess/parser_raw.ml" +# 1150 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 19403 "src/ocaml/preprocess/parser_raw.ml" in -# 1985 "src/ocaml/preprocess/parser_raw.mly" - ( params ) -# 13068 "src/ocaml/preprocess/parser_raw.ml" +# 2942 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 19409 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13087,145 +19428,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.expression) = -# 2764 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 13093 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - } = _menhir_stack in - let _3 : (Parsetree.expression) = Obj.magic _3 in - let _2 : unit = Obj.magic _2 in - let _1 : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__3_ in - let _v : (Parsetree.expression) = let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 2766 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp_constraint ~loc:_sloc _3 _1 ) -# 13135 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - } = _menhir_stack in - let _2 : (Parsetree.expression) = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__2_ in - let _v : (Parsetree.expression) = -# 2791 "src/ocaml/preprocess/parser_raw.mly" - ( (merloc _endpos__1_ _2) ) -# 13167 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - } = _menhir_stack in - let _4 : (Parsetree.expression) = Obj.magic _4 in - let _3 : unit = Obj.magic _3 in - let _2 : (Parsetree.core_type) = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__4_ in - let _v : (Parsetree.expression) = let _1 = - let _1 = -# 2793 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_constraint ((merloc _endpos__3_ _4), _2) ) -# 13214 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos__1_ = _endpos__4_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 13223 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 2794 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 13229 "src/ocaml/preprocess/parser_raw.ml" +# 2416 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 19434 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13249,21 +19454,70 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; }; } = _menhir_stack in - let _2 : (Parsetree.expression) = Obj.magic _2 in - let _1 : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = Obj.magic _1 in + let _2 : unit = Obj.magic _2 in + let _1 : (Parsetree.expression) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in - let _v : (Parsetree.expression) = let _endpos = _endpos__2_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in + let _v : (Parsetree.expression) = +# 2417 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 19466 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _3 : (Parsetree.expression) = Obj.magic _3 in + let _2 : unit = Obj.magic _2 in + let _1 : (Parsetree.expression) = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__3_ in + let _v : (Parsetree.expression) = let _1 = + let _1 = +# 2419 "src/ocaml/preprocess/parser_raw.mly" + ( Pexp_sequence(_1, _3) ) +# 19506 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos__1_ = _endpos__3_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1060 "src/ocaml/preprocess/parser_raw.mly" + ( mkexp ~loc:_sloc _1 ) +# 19515 "src/ocaml/preprocess/parser_raw.ml" + + in -# 2797 "src/ocaml/preprocess/parser_raw.mly" - ( - let (l,o,p) = _1 in - ghexp ~loc:_sloc (Pexp_fun(l, o, p, _2)) - ) -# 13267 "src/ocaml/preprocess/parser_raw.ml" +# 2420 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 19521 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13286,9 +19540,9 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = xs; - MenhirLib.EngineTypes.startp = _startpos_xs_; - MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _2; @@ -13306,25 +19560,22 @@ module Tables = struct }; } = _menhir_stack in let _5 : (Parsetree.expression) = Obj.magic _5 in - let _4 : unit = Obj.magic _4 in - let xs : (string Location.loc list) = Obj.magic xs in + let _4 : (string Location.loc) = Obj.magic _4 in + let _3 : unit = Obj.magic _3 in let _2 : unit = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in + let _1 : (Parsetree.expression) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in - let _v : (Parsetree.expression) = let _3 = -# 2662 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 13320 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos = _endpos__5_ in + let _v : (Parsetree.expression) = let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2802 "src/ocaml/preprocess/parser_raw.mly" - ( mk_newtypes ~loc:_sloc _3 _5 ) -# 13328 "src/ocaml/preprocess/parser_raw.ml" +# 2422 "src/ocaml/preprocess/parser_raw.mly" + ( let seq = mkexp ~loc:_sloc (Pexp_sequence (_1, _5)) in + let payload = PStr [mkstrexp seq []] in + mkexp ~loc:_sloc (Pexp_extension (_4, payload)) ) +# 19579 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13347,9 +19598,9 @@ module Tables = struct let _startpos = _startpos_ty_ in let _endpos = _endpos_ty_ in let _v : (Parsetree.core_type) = -# 3507 "src/ocaml/preprocess/parser_raw.mly" +# 3647 "src/ocaml/preprocess/parser_raw.mly" ( ty ) -# 13353 "src/ocaml/preprocess/parser_raw.ml" +# 19604 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13395,19 +19646,19 @@ module Tables = struct let _v : (Parsetree.core_type) = let _1 = let _1 = let domain = -# 988 "src/ocaml/preprocess/parser_raw.mly" +# 1025 "src/ocaml/preprocess/parser_raw.mly" ( extra_rhs_core_type _1 ~pos:_endpos__1_ ) -# 13401 "src/ocaml/preprocess/parser_raw.ml" +# 19652 "src/ocaml/preprocess/parser_raw.ml" in let label = -# 3519 "src/ocaml/preprocess/parser_raw.mly" +# 3659 "src/ocaml/preprocess/parser_raw.mly" ( Optional label ) -# 13406 "src/ocaml/preprocess/parser_raw.ml" +# 19657 "src/ocaml/preprocess/parser_raw.ml" in -# 3513 "src/ocaml/preprocess/parser_raw.mly" +# 3653 "src/ocaml/preprocess/parser_raw.mly" ( Ptyp_arrow(label, domain, codomain) ) -# 13411 "src/ocaml/preprocess/parser_raw.ml" +# 19662 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_label_) in @@ -13415,15 +19666,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 13421 "src/ocaml/preprocess/parser_raw.ml" +# 19672 "src/ocaml/preprocess/parser_raw.ml" in -# 3515 "src/ocaml/preprocess/parser_raw.mly" +# 3655 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 13427 "src/ocaml/preprocess/parser_raw.ml" +# 19678 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13470,9 +19721,9 @@ module Tables = struct let _1 : (Parsetree.core_type) = Obj.magic _1 in let _2 : unit = Obj.magic _2 in let label : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 13476 "src/ocaml/preprocess/parser_raw.ml" +# 19727 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic label in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_label_ in @@ -13480,19 +19731,19 @@ module Tables = struct let _v : (Parsetree.core_type) = let _1 = let _1 = let domain = -# 988 "src/ocaml/preprocess/parser_raw.mly" +# 1025 "src/ocaml/preprocess/parser_raw.mly" ( extra_rhs_core_type _1 ~pos:_endpos__1_ ) -# 13486 "src/ocaml/preprocess/parser_raw.ml" +# 19737 "src/ocaml/preprocess/parser_raw.ml" in let label = -# 3521 "src/ocaml/preprocess/parser_raw.mly" +# 3661 "src/ocaml/preprocess/parser_raw.mly" ( Labelled label ) -# 13491 "src/ocaml/preprocess/parser_raw.ml" +# 19742 "src/ocaml/preprocess/parser_raw.ml" in -# 3513 "src/ocaml/preprocess/parser_raw.mly" +# 3653 "src/ocaml/preprocess/parser_raw.mly" ( Ptyp_arrow(label, domain, codomain) ) -# 13496 "src/ocaml/preprocess/parser_raw.ml" +# 19747 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_label_) in @@ -13500,15 +19751,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 13506 "src/ocaml/preprocess/parser_raw.ml" +# 19757 "src/ocaml/preprocess/parser_raw.ml" in -# 3515 "src/ocaml/preprocess/parser_raw.mly" +# 3655 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 13512 "src/ocaml/preprocess/parser_raw.ml" +# 19763 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13547,19 +19798,19 @@ module Tables = struct let _v : (Parsetree.core_type) = let _1 = let _1 = let domain = -# 988 "src/ocaml/preprocess/parser_raw.mly" +# 1025 "src/ocaml/preprocess/parser_raw.mly" ( extra_rhs_core_type _1 ~pos:_endpos__1_ ) -# 13553 "src/ocaml/preprocess/parser_raw.ml" +# 19804 "src/ocaml/preprocess/parser_raw.ml" in let label = -# 3523 "src/ocaml/preprocess/parser_raw.mly" +# 3663 "src/ocaml/preprocess/parser_raw.mly" ( Nolabel ) -# 13558 "src/ocaml/preprocess/parser_raw.ml" +# 19809 "src/ocaml/preprocess/parser_raw.ml" in -# 3513 "src/ocaml/preprocess/parser_raw.mly" +# 3653 "src/ocaml/preprocess/parser_raw.mly" ( Ptyp_arrow(label, domain, codomain) ) -# 13563 "src/ocaml/preprocess/parser_raw.ml" +# 19814 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos_codomain_ in @@ -13567,15 +19818,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 13573 "src/ocaml/preprocess/parser_raw.ml" +# 19824 "src/ocaml/preprocess/parser_raw.ml" in -# 3515 "src/ocaml/preprocess/parser_raw.mly" +# 3655 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 13579 "src/ocaml/preprocess/parser_raw.ml" +# 19830 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13606,9 +19857,9 @@ module Tables = struct let _endpos = _endpos__2_ in let _v : (Lexing.position * Parsetree.functor_parameter) = let _startpos = _startpos__1_ in -# 1379 "src/ocaml/preprocess/parser_raw.mly" +# 1437 "src/ocaml/preprocess/parser_raw.mly" ( _startpos, Unit ) -# 13612 "src/ocaml/preprocess/parser_raw.ml" +# 19863 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13664,16 +19915,16 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 13670 "src/ocaml/preprocess/parser_raw.ml" +# 19921 "src/ocaml/preprocess/parser_raw.ml" in let _startpos = _startpos__1_ in -# 1382 "src/ocaml/preprocess/parser_raw.mly" +# 1440 "src/ocaml/preprocess/parser_raw.mly" ( _startpos, Named (x, mty) ) -# 13677 "src/ocaml/preprocess/parser_raw.ml" +# 19928 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13696,9 +19947,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : ((Lexing.position * Parsetree.functor_parameter) list) = -# 1371 "src/ocaml/preprocess/parser_raw.mly" +# 1429 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 13702 "src/ocaml/preprocess/parser_raw.ml" +# 19953 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13715,9 +19966,9 @@ module Tables = struct let _endpos = _startpos in let _v : (Ocaml_parsing.Ast_helper.str list * Parsetree.constructor_arguments * Parsetree.core_type option) = -# 3306 "src/ocaml/preprocess/parser_raw.mly" +# 3446 "src/ocaml/preprocess/parser_raw.mly" ( ([],Pcstr_tuple [],None) ) -# 13721 "src/ocaml/preprocess/parser_raw.ml" +# 19972 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13748,9 +19999,9 @@ module Tables = struct let _endpos = _endpos__2_ in let _v : (Ocaml_parsing.Ast_helper.str list * Parsetree.constructor_arguments * Parsetree.core_type option) = -# 3307 "src/ocaml/preprocess/parser_raw.mly" +# 3447 "src/ocaml/preprocess/parser_raw.mly" ( ([],_2,None) ) -# 13754 "src/ocaml/preprocess/parser_raw.ml" +# 20005 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13795,9 +20046,9 @@ module Tables = struct let _endpos = _endpos__4_ in let _v : (Ocaml_parsing.Ast_helper.str list * Parsetree.constructor_arguments * Parsetree.core_type option) = -# 3309 "src/ocaml/preprocess/parser_raw.mly" +# 3449 "src/ocaml/preprocess/parser_raw.mly" ( ([],_2,Some _4) ) -# 13801 "src/ocaml/preprocess/parser_raw.ml" +# 20052 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13860,24 +20111,24 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 13864 "src/ocaml/preprocess/parser_raw.ml" +# 20115 "src/ocaml/preprocess/parser_raw.ml" in -# 1092 "src/ocaml/preprocess/parser_raw.mly" +# 1129 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 13869 "src/ocaml/preprocess/parser_raw.ml" +# 20120 "src/ocaml/preprocess/parser_raw.ml" in -# 3442 "src/ocaml/preprocess/parser_raw.mly" +# 3582 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 13875 "src/ocaml/preprocess/parser_raw.ml" +# 20126 "src/ocaml/preprocess/parser_raw.ml" in -# 3312 "src/ocaml/preprocess/parser_raw.mly" +# 3452 "src/ocaml/preprocess/parser_raw.mly" ( (_2,_4,Some _6) ) -# 13881 "src/ocaml/preprocess/parser_raw.ml" +# 20132 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13908,9 +20159,9 @@ module Tables = struct let _endpos = _endpos__2_ in let _v : (Ocaml_parsing.Ast_helper.str list * Parsetree.constructor_arguments * Parsetree.core_type option) = -# 3314 "src/ocaml/preprocess/parser_raw.mly" +# 3454 "src/ocaml/preprocess/parser_raw.mly" ( ([],Pcstr_tuple [],Some _2) ) -# 13914 "src/ocaml/preprocess/parser_raw.ml" +# 20165 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -13959,24 +20210,24 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 13963 "src/ocaml/preprocess/parser_raw.ml" +# 20214 "src/ocaml/preprocess/parser_raw.ml" in -# 1092 "src/ocaml/preprocess/parser_raw.mly" +# 1129 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 13968 "src/ocaml/preprocess/parser_raw.ml" +# 20219 "src/ocaml/preprocess/parser_raw.ml" in -# 3442 "src/ocaml/preprocess/parser_raw.mly" +# 3582 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 13974 "src/ocaml/preprocess/parser_raw.ml" +# 20225 "src/ocaml/preprocess/parser_raw.ml" in -# 3316 "src/ocaml/preprocess/parser_raw.mly" +# 3456 "src/ocaml/preprocess/parser_raw.mly" ( (_2,Pcstr_tuple [],Some _4) ) -# 13980 "src/ocaml/preprocess/parser_raw.ml" +# 20231 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14025,9 +20276,9 @@ module Tables = struct Parsetree.attributes * Location.t * Ocaml_parsing.Docstrings.info) = let attrs = let _1 = _1_inlined2 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14031 "src/ocaml/preprocess/parser_raw.ml" +# 20282 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs_ = _endpos__1_inlined2_ in @@ -14037,23 +20288,23 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 14043 "src/ocaml/preprocess/parser_raw.ml" +# 20294 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3254 "src/ocaml/preprocess/parser_raw.mly" +# 3394 "src/ocaml/preprocess/parser_raw.mly" ( let vars, args, res = vars_args_res in let info = symbol_info _endpos in let loc = make_loc _sloc in cid, vars, args, res, attrs, loc, info ) -# 14057 "src/ocaml/preprocess/parser_raw.ml" +# 20308 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14095,9 +20346,9 @@ module Tables = struct Parsetree.attributes * Location.t * Ocaml_parsing.Docstrings.info) = let attrs = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14101 "src/ocaml/preprocess/parser_raw.ml" +# 20352 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs_ = _endpos__1_inlined1_ in @@ -14106,29 +20357,29 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 14112 "src/ocaml/preprocess/parser_raw.ml" +# 20363 "src/ocaml/preprocess/parser_raw.ml" in let _startpos_cid_ = _startpos__1_ in let _1 = -# 3852 "src/ocaml/preprocess/parser_raw.mly" +# 4048 "src/ocaml/preprocess/parser_raw.mly" ( () ) -# 14119 "src/ocaml/preprocess/parser_raw.ml" +# 20370 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs_ in let _symbolstartpos = _startpos_cid_ in let _sloc = (_symbolstartpos, _endpos) in -# 3254 "src/ocaml/preprocess/parser_raw.mly" +# 3394 "src/ocaml/preprocess/parser_raw.mly" ( let vars, args, res = vars_args_res in let info = symbol_info _endpos in let loc = make_loc _sloc in cid, vars, args, res, attrs, loc, info ) -# 14132 "src/ocaml/preprocess/parser_raw.ml" +# 20383 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14199,9 +20450,9 @@ module Tables = struct let _2 : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic _2 in let _1_inlined3 : unit = Obj.magic _1_inlined3 in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 14205 "src/ocaml/preprocess/parser_raw.ml" +# 20456 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in @@ -14214,9 +20465,9 @@ module Tables = struct Parsetree.type_declaration) = let attrs2 = let _1 = _1_inlined4 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14220 "src/ocaml/preprocess/parser_raw.ml" +# 20471 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined4_ in @@ -14225,26 +20476,26 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 14229 "src/ocaml/preprocess/parser_raw.ml" +# 20480 "src/ocaml/preprocess/parser_raw.ml" in -# 1074 "src/ocaml/preprocess/parser_raw.mly" +# 1111 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 14234 "src/ocaml/preprocess/parser_raw.ml" +# 20485 "src/ocaml/preprocess/parser_raw.ml" in -# 3157 "src/ocaml/preprocess/parser_raw.mly" +# 3297 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14240 "src/ocaml/preprocess/parser_raw.ml" +# 20491 "src/ocaml/preprocess/parser_raw.ml" in let kind_priv_manifest = let _1 = _1_inlined3 in -# 3192 "src/ocaml/preprocess/parser_raw.mly" +# 3332 "src/ocaml/preprocess/parser_raw.mly" ( _2 ) -# 14248 "src/ocaml/preprocess/parser_raw.ml" +# 20499 "src/ocaml/preprocess/parser_raw.ml" in let id = @@ -14253,29 +20504,29 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 14259 "src/ocaml/preprocess/parser_raw.ml" +# 20510 "src/ocaml/preprocess/parser_raw.ml" in let flag = -# 3872 "src/ocaml/preprocess/parser_raw.mly" +# 4068 "src/ocaml/preprocess/parser_raw.mly" ( Recursive ) -# 14265 "src/ocaml/preprocess/parser_raw.ml" +# 20516 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14272 "src/ocaml/preprocess/parser_raw.ml" +# 20523 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3129 "src/ocaml/preprocess/parser_raw.mly" +# 3269 "src/ocaml/preprocess/parser_raw.mly" ( let (kind, priv, manifest) = kind_priv_manifest in let docs = symbol_docs _sloc in @@ -14284,7 +20535,7 @@ module Tables = struct (flag, ext), Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs ) -# 14288 "src/ocaml/preprocess/parser_raw.ml" +# 20539 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14361,9 +20612,9 @@ module Tables = struct let _2 : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic _2 in let _1_inlined4 : unit = Obj.magic _1_inlined4 in let _1_inlined3 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 14367 "src/ocaml/preprocess/parser_raw.ml" +# 20618 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined3 in let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in let _1_inlined2 : unit = Obj.magic _1_inlined2 in @@ -14377,9 +20628,9 @@ module Tables = struct Parsetree.type_declaration) = let attrs2 = let _1 = _1_inlined5 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14383 "src/ocaml/preprocess/parser_raw.ml" +# 20634 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined5_ in @@ -14388,26 +20639,26 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 14392 "src/ocaml/preprocess/parser_raw.ml" +# 20643 "src/ocaml/preprocess/parser_raw.ml" in -# 1074 "src/ocaml/preprocess/parser_raw.mly" +# 1111 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 14397 "src/ocaml/preprocess/parser_raw.ml" +# 20648 "src/ocaml/preprocess/parser_raw.ml" in -# 3157 "src/ocaml/preprocess/parser_raw.mly" +# 3297 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14403 "src/ocaml/preprocess/parser_raw.ml" +# 20654 "src/ocaml/preprocess/parser_raw.ml" in let kind_priv_manifest = let _1 = _1_inlined4 in -# 3192 "src/ocaml/preprocess/parser_raw.mly" +# 3332 "src/ocaml/preprocess/parser_raw.mly" ( _2 ) -# 14411 "src/ocaml/preprocess/parser_raw.ml" +# 20662 "src/ocaml/preprocess/parser_raw.ml" in let id = @@ -14416,9 +20667,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 14422 "src/ocaml/preprocess/parser_raw.ml" +# 20673 "src/ocaml/preprocess/parser_raw.ml" in let flag = @@ -14427,24 +20678,24 @@ module Tables = struct let _startpos = _startpos__1_ in let _loc = (_startpos, _endpos) in -# 3874 "src/ocaml/preprocess/parser_raw.mly" +# 4070 "src/ocaml/preprocess/parser_raw.mly" ( not_expecting _loc "nonrec flag"; Recursive ) -# 14433 "src/ocaml/preprocess/parser_raw.ml" +# 20684 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14441 "src/ocaml/preprocess/parser_raw.ml" +# 20692 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3129 "src/ocaml/preprocess/parser_raw.mly" +# 3269 "src/ocaml/preprocess/parser_raw.mly" ( let (kind, priv, manifest) = kind_priv_manifest in let docs = symbol_docs _sloc in @@ -14453,7 +20704,7 @@ module Tables = struct (flag, ext), Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs ) -# 14457 "src/ocaml/preprocess/parser_raw.ml" +# 20708 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14517,9 +20768,9 @@ module Tables = struct let xs : ((Parsetree.core_type * Parsetree.core_type * Location.t) list) = Obj.magic xs in let kind_priv_manifest : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic kind_priv_manifest in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 14523 "src/ocaml/preprocess/parser_raw.ml" +# 20774 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in @@ -14532,9 +20783,9 @@ module Tables = struct Parsetree.type_declaration) = let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14538 "src/ocaml/preprocess/parser_raw.ml" +# 20789 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -14543,18 +20794,18 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 14547 "src/ocaml/preprocess/parser_raw.ml" +# 20798 "src/ocaml/preprocess/parser_raw.ml" in -# 1074 "src/ocaml/preprocess/parser_raw.mly" +# 1111 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 14552 "src/ocaml/preprocess/parser_raw.ml" +# 20803 "src/ocaml/preprocess/parser_raw.ml" in -# 3157 "src/ocaml/preprocess/parser_raw.mly" +# 3297 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14558 "src/ocaml/preprocess/parser_raw.ml" +# 20809 "src/ocaml/preprocess/parser_raw.ml" in let id = @@ -14563,29 +20814,29 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 14569 "src/ocaml/preprocess/parser_raw.ml" +# 20820 "src/ocaml/preprocess/parser_raw.ml" in let flag = -# 3868 "src/ocaml/preprocess/parser_raw.mly" +# 4064 "src/ocaml/preprocess/parser_raw.mly" ( Recursive ) -# 14575 "src/ocaml/preprocess/parser_raw.ml" +# 20826 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14582 "src/ocaml/preprocess/parser_raw.ml" +# 20833 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3129 "src/ocaml/preprocess/parser_raw.mly" +# 3269 "src/ocaml/preprocess/parser_raw.mly" ( let (kind, priv, manifest) = kind_priv_manifest in let docs = symbol_docs _sloc in @@ -14594,7 +20845,7 @@ module Tables = struct (flag, ext), Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs ) -# 14598 "src/ocaml/preprocess/parser_raw.ml" +# 20849 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14664,9 +20915,9 @@ module Tables = struct let xs : ((Parsetree.core_type * Parsetree.core_type * Location.t) list) = Obj.magic xs in let kind_priv_manifest : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic kind_priv_manifest in let _1_inlined3 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 14670 "src/ocaml/preprocess/parser_raw.ml" +# 20921 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined3 in let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in let _1_inlined2 : unit = Obj.magic _1_inlined2 in @@ -14680,9 +20931,9 @@ module Tables = struct Parsetree.type_declaration) = let attrs2 = let _1 = _1_inlined4 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14686 "src/ocaml/preprocess/parser_raw.ml" +# 20937 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined4_ in @@ -14691,18 +20942,18 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 14695 "src/ocaml/preprocess/parser_raw.ml" +# 20946 "src/ocaml/preprocess/parser_raw.ml" in -# 1074 "src/ocaml/preprocess/parser_raw.mly" +# 1111 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 14700 "src/ocaml/preprocess/parser_raw.ml" +# 20951 "src/ocaml/preprocess/parser_raw.ml" in -# 3157 "src/ocaml/preprocess/parser_raw.mly" +# 3297 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14706 "src/ocaml/preprocess/parser_raw.ml" +# 20957 "src/ocaml/preprocess/parser_raw.ml" in let id = @@ -14711,32 +20962,32 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 14717 "src/ocaml/preprocess/parser_raw.ml" +# 20968 "src/ocaml/preprocess/parser_raw.ml" in let flag = let _1 = _1_inlined2 in -# 3869 "src/ocaml/preprocess/parser_raw.mly" +# 4065 "src/ocaml/preprocess/parser_raw.mly" ( Nonrecursive ) -# 14725 "src/ocaml/preprocess/parser_raw.ml" +# 20976 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14733 "src/ocaml/preprocess/parser_raw.ml" +# 20984 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3129 "src/ocaml/preprocess/parser_raw.mly" +# 3269 "src/ocaml/preprocess/parser_raw.mly" ( let (kind, priv, manifest) = kind_priv_manifest in let docs = symbol_docs _sloc in @@ -14745,7 +20996,7 @@ module Tables = struct (flag, ext), Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs ) -# 14749 "src/ocaml/preprocess/parser_raw.ml" +# 21000 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14764,17 +21015,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 845 "src/ocaml/preprocess/parser_raw.mly" +# 890 "src/ocaml/preprocess/parser_raw.mly" (string) -# 14770 "src/ocaml/preprocess/parser_raw.ml" +# 21021 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3707 "src/ocaml/preprocess/parser_raw.mly" +# 3903 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14778 "src/ocaml/preprocess/parser_raw.ml" +# 21029 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14793,17 +21044,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 14799 "src/ocaml/preprocess/parser_raw.ml" +# 21050 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3708 "src/ocaml/preprocess/parser_raw.mly" +# 3904 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14807 "src/ocaml/preprocess/parser_raw.ml" +# 21058 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14833,9 +21084,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.structure) = -# 1245 "src/ocaml/preprocess/parser_raw.mly" +# 1303 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14839 "src/ocaml/preprocess/parser_raw.ml" +# 21090 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14851,9 +21102,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (string) = -# 3759 "src/ocaml/preprocess/parser_raw.mly" +# 3955 "src/ocaml/preprocess/parser_raw.mly" ( "" ) -# 14857 "src/ocaml/preprocess/parser_raw.ml" +# 21108 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14883,9 +21134,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (string) = -# 3760 "src/ocaml/preprocess/parser_raw.mly" +# 3956 "src/ocaml/preprocess/parser_raw.mly" ( ";.." ) -# 14889 "src/ocaml/preprocess/parser_raw.ml" +# 21140 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14915,9 +21166,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.signature) = -# 1252 "src/ocaml/preprocess/parser_raw.mly" +# 1310 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 14921 "src/ocaml/preprocess/parser_raw.ml" +# 21172 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14961,9 +21212,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : (Parsetree.extension) = -# 4052 "src/ocaml/preprocess/parser_raw.mly" +# 4248 "src/ocaml/preprocess/parser_raw.mly" ( (_2, _3) ) -# 14967 "src/ocaml/preprocess/parser_raw.ml" +# 21218 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -14982,9 +21233,9 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 836 "src/ocaml/preprocess/parser_raw.mly" +# 881 "src/ocaml/preprocess/parser_raw.mly" (string * Location.t * string * Location.t * string option) -# 14988 "src/ocaml/preprocess/parser_raw.ml" +# 21239 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -14993,9 +21244,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 4054 "src/ocaml/preprocess/parser_raw.mly" +# 4250 "src/ocaml/preprocess/parser_raw.mly" ( mk_quotedext ~loc:_sloc _1 ) -# 14999 "src/ocaml/preprocess/parser_raw.ml" +# 21250 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15041,9 +21292,9 @@ module Tables = struct let _1_inlined2 : (Parsetree.core_type) = Obj.magic _1_inlined2 in let _3 : unit = Obj.magic _3 in let _1_inlined1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 15047 "src/ocaml/preprocess/parser_raw.ml" +# 21298 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined1 in let _1 : (Asttypes.mutable_flag) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -15052,34 +21303,34 @@ module Tables = struct let _v : (Parsetree.label_declaration) = let _5 = let _1 = _1_inlined3 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 15058 "src/ocaml/preprocess/parser_raw.ml" +# 21309 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__5_ = _endpos__1_inlined3_ in let _4 = let _1 = _1_inlined2 in -# 3460 "src/ocaml/preprocess/parser_raw.mly" +# 3600 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 15067 "src/ocaml/preprocess/parser_raw.ml" +# 21318 "src/ocaml/preprocess/parser_raw.ml" in let _2 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 15075 "src/ocaml/preprocess/parser_raw.ml" +# 21326 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 15083 "src/ocaml/preprocess/parser_raw.ml" +# 21334 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__2_ = _startpos__1_inlined1_ in @@ -15090,10 +21341,10 @@ module Tables = struct _startpos__2_ in let _sloc = (_symbolstartpos, _endpos) in -# 3333 "src/ocaml/preprocess/parser_raw.mly" +# 3473 "src/ocaml/preprocess/parser_raw.mly" ( let info = symbol_info _endpos in Type.field _2 _4 ~mut:_1 ~attrs:_5 ~loc:(make_loc _sloc) ~info ) -# 15097 "src/ocaml/preprocess/parser_raw.ml" +# 21348 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15153,9 +21404,9 @@ module Tables = struct let _1_inlined2 : (Parsetree.core_type) = Obj.magic _1_inlined2 in let _3 : unit = Obj.magic _3 in let _1_inlined1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 15159 "src/ocaml/preprocess/parser_raw.ml" +# 21410 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined1 in let _1 : (Asttypes.mutable_flag) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -15164,43 +21415,43 @@ module Tables = struct let _v : (Parsetree.label_declaration) = let _7 = let _1 = _1_inlined4 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 15170 "src/ocaml/preprocess/parser_raw.ml" +# 21421 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__7_ = _endpos__1_inlined4_ in let _5 = let _1 = _1_inlined3 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 15179 "src/ocaml/preprocess/parser_raw.ml" +# 21430 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__5_ = _endpos__1_inlined3_ in let _4 = let _1 = _1_inlined2 in -# 3460 "src/ocaml/preprocess/parser_raw.mly" +# 3600 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 15188 "src/ocaml/preprocess/parser_raw.ml" +# 21439 "src/ocaml/preprocess/parser_raw.ml" in let _2 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 15196 "src/ocaml/preprocess/parser_raw.ml" +# 21447 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 15204 "src/ocaml/preprocess/parser_raw.ml" +# 21455 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__2_ = _startpos__1_inlined1_ in @@ -15211,14 +21462,14 @@ module Tables = struct _startpos__2_ in let _sloc = (_symbolstartpos, _endpos) in -# 3338 "src/ocaml/preprocess/parser_raw.mly" +# 3478 "src/ocaml/preprocess/parser_raw.mly" ( let info = match rhs_info _endpos__5_ with | Some _ as info_before_semi -> info_before_semi | None -> symbol_info _endpos in Type.field _2 _4 ~mut:_1 ~attrs:(_5 @ _7) ~loc:(make_loc _sloc) ~info ) -# 15222 "src/ocaml/preprocess/parser_raw.ml" +# 21473 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15241,9 +21492,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.label_declaration list) = -# 3327 "src/ocaml/preprocess/parser_raw.mly" +# 3467 "src/ocaml/preprocess/parser_raw.mly" ( [_1] ) -# 15247 "src/ocaml/preprocess/parser_raw.ml" +# 21498 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15266,9 +21517,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.label_declaration list) = -# 3328 "src/ocaml/preprocess/parser_raw.mly" +# 3468 "src/ocaml/preprocess/parser_raw.mly" ( [_1] ) -# 15272 "src/ocaml/preprocess/parser_raw.ml" +# 21523 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15298,9 +21549,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.label_declaration list) = -# 3329 "src/ocaml/preprocess/parser_raw.mly" +# 3469 "src/ocaml/preprocess/parser_raw.mly" ( _1 :: _2 ) -# 15304 "src/ocaml/preprocess/parser_raw.ml" +# 21555 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15319,9 +21570,9 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 15325 "src/ocaml/preprocess/parser_raw.ml" +# 21576 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -15332,24 +21583,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 15338 "src/ocaml/preprocess/parser_raw.ml" +# 21589 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2363 "src/ocaml/preprocess/parser_raw.mly" +# 2469 "src/ocaml/preprocess/parser_raw.mly" ( (_1.Location.txt, mkpat ~loc:_sloc (Ppat_var _1)) ) -# 15347 "src/ocaml/preprocess/parser_raw.ml" +# 21598 "src/ocaml/preprocess/parser_raw.ml" in -# 2355 "src/ocaml/preprocess/parser_raw.mly" +# 2461 "src/ocaml/preprocess/parser_raw.mly" ( x ) -# 15353 "src/ocaml/preprocess/parser_raw.ml" +# 21604 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15382,9 +21633,9 @@ module Tables = struct let cty : (Parsetree.core_type) = Obj.magic cty in let _2 : unit = Obj.magic _2 in let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 15388 "src/ocaml/preprocess/parser_raw.ml" +# 21639 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -15395,18 +21646,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 15401 "src/ocaml/preprocess/parser_raw.ml" +# 21652 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2363 "src/ocaml/preprocess/parser_raw.mly" +# 2469 "src/ocaml/preprocess/parser_raw.mly" ( (_1.Location.txt, mkpat ~loc:_sloc (Ppat_var _1)) ) -# 15410 "src/ocaml/preprocess/parser_raw.ml" +# 21661 "src/ocaml/preprocess/parser_raw.ml" in let _startpos_x_ = _startpos__1_ in @@ -15414,11 +21665,11 @@ module Tables = struct let _symbolstartpos = _startpos_x_ in let _sloc = (_symbolstartpos, _endpos) in -# 2357 "src/ocaml/preprocess/parser_raw.mly" +# 2463 "src/ocaml/preprocess/parser_raw.mly" ( let lab, pat = x in lab, mkpat ~loc:_sloc (Ppat_constraint (pat, cty)) ) -# 15422 "src/ocaml/preprocess/parser_raw.ml" +# 21673 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15441,9 +21692,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3791 "src/ocaml/preprocess/parser_raw.mly" +# 3987 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 15447 "src/ocaml/preprocess/parser_raw.ml" +# 21698 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15466,9 +21717,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.arg_label * Parsetree.expression) = -# 2645 "src/ocaml/preprocess/parser_raw.mly" +# 2757 "src/ocaml/preprocess/parser_raw.mly" ( (Nolabel, _1) ) -# 15472 "src/ocaml/preprocess/parser_raw.ml" +# 21723 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15494,17 +21745,17 @@ module Tables = struct } = _menhir_stack in let _2 : (Parsetree.expression) = Obj.magic _2 in let _1 : ( -# 780 "src/ocaml/preprocess/parser_raw.mly" +# 825 "src/ocaml/preprocess/parser_raw.mly" (string) -# 15500 "src/ocaml/preprocess/parser_raw.ml" +# 21751 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.arg_label * Parsetree.expression) = -# 2647 "src/ocaml/preprocess/parser_raw.mly" +# 2759 "src/ocaml/preprocess/parser_raw.mly" ( (Labelled _1, _2) ) -# 15508 "src/ocaml/preprocess/parser_raw.ml" +# 21759 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15529,9 +21780,9 @@ module Tables = struct }; } = _menhir_stack in let label : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 15535 "src/ocaml/preprocess/parser_raw.ml" +# 21786 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic label in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -15539,10 +21790,10 @@ module Tables = struct let _endpos = _endpos_label_ in let _v : (Asttypes.arg_label * Parsetree.expression) = let _loc_label_ = (_startpos_label_, _endpos_label_) in -# 2649 "src/ocaml/preprocess/parser_raw.mly" +# 2761 "src/ocaml/preprocess/parser_raw.mly" ( let loc = _loc_label_ in (Labelled label, mkexpvar ~loc label) ) -# 15546 "src/ocaml/preprocess/parser_raw.ml" +# 21797 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15585,11 +21836,11 @@ module Tables = struct }; } = _menhir_stack in let _5 : unit = Obj.magic _5 in - let ty : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic ty in + let ty : (Parsetree.type_constraint) = Obj.magic ty in let label : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 15593 "src/ocaml/preprocess/parser_raw.ml" +# 21844 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic label in let _2 : unit = Obj.magic _2 in let _1 : unit = Obj.magic _1 in @@ -15599,10 +21850,10 @@ module Tables = struct let _v : (Asttypes.arg_label * Parsetree.expression) = let _endpos = _endpos__5_ in let _loc_label_ = (_startpos_label_, _endpos_label_) in -# 2652 "src/ocaml/preprocess/parser_raw.mly" +# 2764 "src/ocaml/preprocess/parser_raw.mly" ( (Labelled label, mkexp_constraint ~loc:(_startpos__2_, _endpos) (mkexpvar ~loc:_loc_label_ label) ty) ) -# 15606 "src/ocaml/preprocess/parser_raw.ml" +# 21857 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15627,9 +21878,9 @@ module Tables = struct }; } = _menhir_stack in let label : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 15633 "src/ocaml/preprocess/parser_raw.ml" +# 21884 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic label in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -15637,10 +21888,10 @@ module Tables = struct let _endpos = _endpos_label_ in let _v : (Asttypes.arg_label * Parsetree.expression) = let _loc_label_ = (_startpos_label_, _endpos_label_) in -# 2655 "src/ocaml/preprocess/parser_raw.mly" +# 2767 "src/ocaml/preprocess/parser_raw.mly" ( let loc = _loc_label_ in (Optional label, mkexpvar ~loc label) ) -# 15644 "src/ocaml/preprocess/parser_raw.ml" +# 21895 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15666,17 +21917,17 @@ module Tables = struct } = _menhir_stack in let _2 : (Parsetree.expression) = Obj.magic _2 in let _1 : ( -# 810 "src/ocaml/preprocess/parser_raw.mly" +# 855 "src/ocaml/preprocess/parser_raw.mly" (string) -# 15672 "src/ocaml/preprocess/parser_raw.ml" +# 21923 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.arg_label * Parsetree.expression) = -# 2658 "src/ocaml/preprocess/parser_raw.mly" +# 2770 "src/ocaml/preprocess/parser_raw.mly" ( (Optional _1, _2) ) -# 15680 "src/ocaml/preprocess/parser_raw.ml" +# 21931 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15729,15 +21980,15 @@ module Tables = struct let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = let _4 = let _1 = _1_inlined1 in -# 2351 "src/ocaml/preprocess/parser_raw.mly" +# 2457 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 15735 "src/ocaml/preprocess/parser_raw.ml" +# 21986 "src/ocaml/preprocess/parser_raw.ml" in -# 2325 "src/ocaml/preprocess/parser_raw.mly" +# 2431 "src/ocaml/preprocess/parser_raw.mly" ( (Optional (fst _3), _4, snd _3) ) -# 15741 "src/ocaml/preprocess/parser_raw.ml" +# 21992 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15762,9 +22013,9 @@ module Tables = struct }; } = _menhir_stack in let _1_inlined1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 15768 "src/ocaml/preprocess/parser_raw.ml" +# 22019 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -15777,24 +22028,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 15783 "src/ocaml/preprocess/parser_raw.ml" +# 22034 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2363 "src/ocaml/preprocess/parser_raw.mly" +# 2469 "src/ocaml/preprocess/parser_raw.mly" ( (_1.Location.txt, mkpat ~loc:_sloc (Ppat_var _1)) ) -# 15792 "src/ocaml/preprocess/parser_raw.ml" +# 22043 "src/ocaml/preprocess/parser_raw.ml" in -# 2327 "src/ocaml/preprocess/parser_raw.mly" +# 2433 "src/ocaml/preprocess/parser_raw.mly" ( (Optional (fst _2), None, snd _2) ) -# 15798 "src/ocaml/preprocess/parser_raw.ml" +# 22049 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15841,9 +22092,9 @@ module Tables = struct let _3 : (Parsetree.pattern) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 810 "src/ocaml/preprocess/parser_raw.mly" +# 855 "src/ocaml/preprocess/parser_raw.mly" (string) -# 15847 "src/ocaml/preprocess/parser_raw.ml" +# 22098 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -15851,15 +22102,15 @@ module Tables = struct let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = let _4 = let _1 = _1_inlined1 in -# 2351 "src/ocaml/preprocess/parser_raw.mly" +# 2457 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 15857 "src/ocaml/preprocess/parser_raw.ml" +# 22108 "src/ocaml/preprocess/parser_raw.ml" in -# 2329 "src/ocaml/preprocess/parser_raw.mly" +# 2435 "src/ocaml/preprocess/parser_raw.mly" ( (Optional _1, _4, _3) ) -# 15863 "src/ocaml/preprocess/parser_raw.ml" +# 22114 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15885,17 +22136,17 @@ module Tables = struct } = _menhir_stack in let _2 : (Parsetree.pattern) = Obj.magic _2 in let _1 : ( -# 810 "src/ocaml/preprocess/parser_raw.mly" +# 855 "src/ocaml/preprocess/parser_raw.mly" (string) -# 15891 "src/ocaml/preprocess/parser_raw.ml" +# 22142 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = -# 2331 "src/ocaml/preprocess/parser_raw.mly" +# 2437 "src/ocaml/preprocess/parser_raw.mly" ( (Optional _1, None, _2) ) -# 15899 "src/ocaml/preprocess/parser_raw.ml" +# 22150 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15939,9 +22190,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = -# 2333 "src/ocaml/preprocess/parser_raw.mly" +# 2439 "src/ocaml/preprocess/parser_raw.mly" ( (Labelled (fst _3), None, snd _3) ) -# 15945 "src/ocaml/preprocess/parser_raw.ml" +# 22196 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -15966,9 +22217,9 @@ module Tables = struct }; } = _menhir_stack in let _1_inlined1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 15972 "src/ocaml/preprocess/parser_raw.ml" +# 22223 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -15981,24 +22232,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 15987 "src/ocaml/preprocess/parser_raw.ml" +# 22238 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2363 "src/ocaml/preprocess/parser_raw.mly" +# 2469 "src/ocaml/preprocess/parser_raw.mly" ( (_1.Location.txt, mkpat ~loc:_sloc (Ppat_var _1)) ) -# 15996 "src/ocaml/preprocess/parser_raw.ml" +# 22247 "src/ocaml/preprocess/parser_raw.ml" in -# 2335 "src/ocaml/preprocess/parser_raw.mly" +# 2441 "src/ocaml/preprocess/parser_raw.mly" ( (Labelled (fst _2), None, snd _2) ) -# 16002 "src/ocaml/preprocess/parser_raw.ml" +# 22253 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16024,17 +22275,17 @@ module Tables = struct } = _menhir_stack in let _2 : (Parsetree.pattern) = Obj.magic _2 in let _1 : ( -# 780 "src/ocaml/preprocess/parser_raw.mly" +# 825 "src/ocaml/preprocess/parser_raw.mly" (string) -# 16030 "src/ocaml/preprocess/parser_raw.ml" +# 22281 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = -# 2337 "src/ocaml/preprocess/parser_raw.mly" +# 2443 "src/ocaml/preprocess/parser_raw.mly" ( (Labelled _1, None, _2) ) -# 16038 "src/ocaml/preprocess/parser_raw.ml" +# 22289 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16057,9 +22308,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = -# 2339 "src/ocaml/preprocess/parser_raw.mly" +# 2445 "src/ocaml/preprocess/parser_raw.mly" ( (Nolabel, None, _1) ) -# 16063 "src/ocaml/preprocess/parser_raw.ml" +# 22314 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16077,14 +22328,16 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let _1 : (Parsetree.pattern * Parsetree.expression) = Obj.magic _1 in + let _1 : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in - let _v : (Parsetree.pattern * Parsetree.expression * bool) = -# 2701 "src/ocaml/preprocess/parser_raw.mly" - ( let p,e = _1 in (p,e,false) ) -# 16088 "src/ocaml/preprocess/parser_raw.ml" + let _v : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option * bool) = +# 2809 "src/ocaml/preprocess/parser_raw.mly" + ( let p,e,c = _1 in (p,e,c,false) ) +# 22341 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16106,13 +22359,14 @@ module Tables = struct let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in - let _v : (Parsetree.pattern * Parsetree.expression * bool) = let _endpos = _endpos__1_ in + let _v : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option * bool) = let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in let _loc = (_startpos, _endpos) in -# 2704 "src/ocaml/preprocess/parser_raw.mly" - ( (mkpatvar ~loc:_loc _1, mkexpvar ~loc:_loc _1, true) ) -# 16116 "src/ocaml/preprocess/parser_raw.ml" +# 2812 "src/ocaml/preprocess/parser_raw.mly" + ( (mkpatvar ~loc:_loc _1, mkexpvar ~loc:_loc _1, None, true) ) +# 22370 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16141,20 +22395,21 @@ module Tables = struct let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in - let _v : (Parsetree.pattern * Parsetree.expression) = let _1 = + let _v : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option) = let _1 = let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2665 "src/ocaml/preprocess/parser_raw.mly" +# 2777 "src/ocaml/preprocess/parser_raw.mly" ( mkpatvar ~loc:_sloc _1 ) -# 16152 "src/ocaml/preprocess/parser_raw.ml" +# 22407 "src/ocaml/preprocess/parser_raw.ml" in -# 2669 "src/ocaml/preprocess/parser_raw.mly" - ( (_1, _2) ) -# 16158 "src/ocaml/preprocess/parser_raw.ml" +# 2781 "src/ocaml/preprocess/parser_raw.mly" + ( (_1, _2, None) ) +# 22413 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16192,39 +22447,34 @@ module Tables = struct } = _menhir_stack in let _4 : (Parsetree.expression) = Obj.magic _4 in let _3 : unit = Obj.magic _3 in - let _2 : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic _2 in + let _2 : (Parsetree.type_constraint) = Obj.magic _2 in let _1 : (string) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in - let _v : (Parsetree.pattern * Parsetree.expression) = let _1 = + let _v : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option) = let _1 = let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2665 "src/ocaml/preprocess/parser_raw.mly" +# 2777 "src/ocaml/preprocess/parser_raw.mly" ( mkpatvar ~loc:_sloc _1 ) -# 16208 "src/ocaml/preprocess/parser_raw.ml" +# 22464 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos = _endpos__4_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in -# 2671 "src/ocaml/preprocess/parser_raw.mly" +# 2783 "src/ocaml/preprocess/parser_raw.mly" ( let v = _1 in (* PR#7344 *) let t = match _2 with - Some t, None -> t - | _, Some t -> t - | _ -> assert false + Pconstraint t -> + Pvc_constraint { locally_abstract_univars = []; typ=t } + | Pcoerce (ground, coercion) -> Pvc_coercion { ground; coercion} in - let loc = Location.(t.ptyp_loc.loc_start, t.ptyp_loc.loc_end) in - let typ = ghtyp ~loc (Ptyp_poly([],t)) in - let patloc = (_startpos__1_, _endpos__2_) in - (ghpat ~loc:patloc (Ppat_constraint(v, typ)), - mkexp_constraint ~loc:_sloc _4 _2) ) -# 16228 "src/ocaml/preprocess/parser_raw.ml" + (v, _4, Some t) + ) +# 22478 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16288,31 +22538,32 @@ module Tables = struct let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in - let _v : (Parsetree.pattern * Parsetree.expression) = let _3 = + let _v : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option) = let _3 = let _2 = _2_inlined1 in let _1 = let _1 = let xs = # 253 "" ( List.rev xs ) -# 16299 "src/ocaml/preprocess/parser_raw.ml" +# 22550 "src/ocaml/preprocess/parser_raw.ml" in -# 1092 "src/ocaml/preprocess/parser_raw.mly" +# 1129 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 16304 "src/ocaml/preprocess/parser_raw.ml" +# 22555 "src/ocaml/preprocess/parser_raw.ml" in -# 3442 "src/ocaml/preprocess/parser_raw.mly" +# 3582 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 16310 "src/ocaml/preprocess/parser_raw.ml" +# 22561 "src/ocaml/preprocess/parser_raw.ml" in -# 3446 "src/ocaml/preprocess/parser_raw.mly" +# 3586 "src/ocaml/preprocess/parser_raw.mly" ( Ptyp_poly(_1, _3) ) -# 16316 "src/ocaml/preprocess/parser_raw.ml" +# 22567 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__3_ = _startpos_xs_ in @@ -16321,19 +22572,19 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2665 "src/ocaml/preprocess/parser_raw.mly" +# 2777 "src/ocaml/preprocess/parser_raw.mly" ( mkpatvar ~loc:_sloc _1 ) -# 16327 "src/ocaml/preprocess/parser_raw.ml" +# 22578 "src/ocaml/preprocess/parser_raw.ml" in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2684 "src/ocaml/preprocess/parser_raw.mly" - ( let patloc = (_startpos__1_, _endpos__3_) in - (ghpat ~loc:patloc - (Ppat_constraint(_1, ghtyp ~loc:(_loc__3_) _3)), - _5) ) -# 16337 "src/ocaml/preprocess/parser_raw.ml" +# 2793 "src/ocaml/preprocess/parser_raw.mly" + ( + let t = ghtyp ~loc:(_loc__3_) _3 in + (_1, _5, Some (Pvc_constraint { locally_abstract_univars = []; typ=t })) + ) +# 22588 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16404,31 +22655,29 @@ module Tables = struct let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__8_ in - let _v : (Parsetree.pattern * Parsetree.expression) = let _4 = -# 2662 "src/ocaml/preprocess/parser_raw.mly" + let _v : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option) = let _4 = +# 2774 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 16411 "src/ocaml/preprocess/parser_raw.ml" +# 22663 "src/ocaml/preprocess/parser_raw.ml" in let _1 = let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2665 "src/ocaml/preprocess/parser_raw.mly" +# 2777 "src/ocaml/preprocess/parser_raw.mly" ( mkpatvar ~loc:_sloc _1 ) -# 16420 "src/ocaml/preprocess/parser_raw.ml" +# 22672 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos = _endpos__8_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in -# 2689 "src/ocaml/preprocess/parser_raw.mly" - ( let exp, poly = - wrap_type_annotation ~loc:_sloc _4 _6 _8 in - let loc = (_startpos__1_, _endpos__6_) in - (ghpat ~loc (Ppat_constraint(_1, poly)), exp) ) -# 16432 "src/ocaml/preprocess/parser_raw.ml" +# 2798 "src/ocaml/preprocess/parser_raw.mly" + ( let constraint' = + Pvc_constraint { locally_abstract_univars=_4; typ = _6} + in + (_1, _8, Some constraint') ) +# 22681 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16464,10 +22713,11 @@ module Tables = struct let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in - let _v : (Parsetree.pattern * Parsetree.expression) = -# 2694 "src/ocaml/preprocess/parser_raw.mly" - ( (_1, _3) ) -# 16471 "src/ocaml/preprocess/parser_raw.ml" + let _v : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option) = +# 2803 "src/ocaml/preprocess/parser_raw.mly" + ( (_1, _3, None) ) +# 22721 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16517,11 +22767,11 @@ module Tables = struct let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in - let _v : (Parsetree.pattern * Parsetree.expression) = -# 2696 "src/ocaml/preprocess/parser_raw.mly" - ( let loc = (_startpos__1_, _endpos__3_) in - (ghpat ~loc (Ppat_constraint(_1, _3)), _5) ) -# 16525 "src/ocaml/preprocess/parser_raw.ml" + let _v : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option) = +# 2805 "src/ocaml/preprocess/parser_raw.mly" + ( (_1, _5, Some(Pvc_constraint { locally_abstract_univars=[]; typ=_3 })) ) +# 22775 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16570,7 +22820,8 @@ module Tables = struct }; } = _menhir_stack in let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let body : (Parsetree.pattern * Parsetree.expression * bool) = Obj.magic body in + let body : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option * bool) = Obj.magic body in let rec_flag : (Asttypes.rec_flag) = Obj.magic rec_flag in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in let ext : (string Location.loc option) = Obj.magic ext in @@ -16582,36 +22833,36 @@ module Tables = struct let attrs2 = let _1 = _1_inlined2 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 16588 "src/ocaml/preprocess/parser_raw.ml" +# 22839 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined2_ in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 16597 "src/ocaml/preprocess/parser_raw.ml" +# 22848 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2724 "src/ocaml/preprocess/parser_raw.mly" +# 2832 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in mklbs ext rec_flag (mklb ~loc:_sloc true body attrs) ) -# 16609 "src/ocaml/preprocess/parser_raw.ml" +# 22860 "src/ocaml/preprocess/parser_raw.ml" in -# 2714 "src/ocaml/preprocess/parser_raw.mly" +# 2822 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 16615 "src/ocaml/preprocess/parser_raw.ml" +# 22866 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16641,9 +22892,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Ast_helper.let_bindings) = -# 2715 "src/ocaml/preprocess/parser_raw.mly" +# 2823 "src/ocaml/preprocess/parser_raw.mly" ( addlb _1 _2 ) -# 16647 "src/ocaml/preprocess/parser_raw.ml" +# 22898 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16686,7 +22937,8 @@ module Tables = struct }; } = _menhir_stack in let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let body : (Parsetree.pattern * Parsetree.expression * bool) = Obj.magic body in + let body : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option * bool) = Obj.magic body in let rec_flag : (Asttypes.rec_flag) = Obj.magic rec_flag in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in @@ -16697,41 +22949,41 @@ module Tables = struct let attrs2 = let _1 = _1_inlined2 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 16703 "src/ocaml/preprocess/parser_raw.ml" +# 22955 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined2_ in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 16712 "src/ocaml/preprocess/parser_raw.ml" +# 22964 "src/ocaml/preprocess/parser_raw.ml" in let ext = -# 4038 "src/ocaml/preprocess/parser_raw.mly" +# 4234 "src/ocaml/preprocess/parser_raw.mly" ( None ) -# 16718 "src/ocaml/preprocess/parser_raw.ml" +# 22970 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2724 "src/ocaml/preprocess/parser_raw.mly" +# 2832 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in mklbs ext rec_flag (mklb ~loc:_sloc true body attrs) ) -# 16729 "src/ocaml/preprocess/parser_raw.ml" +# 22981 "src/ocaml/preprocess/parser_raw.ml" in -# 2714 "src/ocaml/preprocess/parser_raw.mly" +# 2822 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 16735 "src/ocaml/preprocess/parser_raw.ml" +# 22987 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16786,7 +23038,8 @@ module Tables = struct }; } = _menhir_stack in let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in - let body : (Parsetree.pattern * Parsetree.expression * bool) = Obj.magic body in + let body : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option * bool) = Obj.magic body in let rec_flag : (Asttypes.rec_flag) = Obj.magic rec_flag in let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in let _2 : (string Location.loc) = Obj.magic _2 in @@ -16799,18 +23052,18 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 16805 "src/ocaml/preprocess/parser_raw.ml" +# 23058 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in let attrs1 = let _1 = _1_inlined2 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 16814 "src/ocaml/preprocess/parser_raw.ml" +# 23067 "src/ocaml/preprocess/parser_raw.ml" in let ext = @@ -16819,27 +23072,27 @@ module Tables = struct let _startpos = _startpos__1_ in let _loc = (_startpos, _endpos) in -# 4040 "src/ocaml/preprocess/parser_raw.mly" +# 4236 "src/ocaml/preprocess/parser_raw.mly" ( not_expecting _loc "extension"; None ) -# 16825 "src/ocaml/preprocess/parser_raw.ml" +# 23078 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2724 "src/ocaml/preprocess/parser_raw.mly" +# 2832 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in mklbs ext rec_flag (mklb ~loc:_sloc true body attrs) ) -# 16837 "src/ocaml/preprocess/parser_raw.ml" +# 23090 "src/ocaml/preprocess/parser_raw.ml" in -# 2714 "src/ocaml/preprocess/parser_raw.mly" +# 2822 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 16843 "src/ocaml/preprocess/parser_raw.ml" +# 23096 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16869,9 +23122,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Ast_helper.let_bindings) = -# 2715 "src/ocaml/preprocess/parser_raw.mly" +# 2823 "src/ocaml/preprocess/parser_raw.mly" ( addlb _1 _2 ) -# 16875 "src/ocaml/preprocess/parser_raw.ml" +# 23128 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16894,9 +23147,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = -# 2367 "src/ocaml/preprocess/parser_raw.mly" +# 2473 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 16900 "src/ocaml/preprocess/parser_raw.ml" +# 23153 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16934,24 +23187,24 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2369 "src/ocaml/preprocess/parser_raw.mly" +# 2475 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_constraint(_1, _3) ) -# 16940 "src/ocaml/preprocess/parser_raw.ml" +# 23193 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 16949 "src/ocaml/preprocess/parser_raw.ml" +# 23202 "src/ocaml/preprocess/parser_raw.ml" in -# 2370 "src/ocaml/preprocess/parser_raw.mly" +# 2476 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 16955 "src/ocaml/preprocess/parser_raw.ml" +# 23208 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -16985,15 +23238,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2665 "src/ocaml/preprocess/parser_raw.mly" +# 2777 "src/ocaml/preprocess/parser_raw.mly" ( mkpatvar ~loc:_sloc _1 ) -# 16991 "src/ocaml/preprocess/parser_raw.ml" +# 23244 "src/ocaml/preprocess/parser_raw.ml" in -# 2741 "src/ocaml/preprocess/parser_raw.mly" +# 2849 "src/ocaml/preprocess/parser_raw.mly" ( (pat, exp) ) -# 16997 "src/ocaml/preprocess/parser_raw.ml" +# 23250 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17019,9 +23272,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _loc = (_startpos, _endpos) in -# 2744 "src/ocaml/preprocess/parser_raw.mly" +# 2852 "src/ocaml/preprocess/parser_raw.mly" ( (mkpatvar ~loc:_loc _1, mkexpvar ~loc:_loc _1) ) -# 17025 "src/ocaml/preprocess/parser_raw.ml" +# 23278 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17072,10 +23325,10 @@ module Tables = struct let _startpos = _startpos_pat_ in let _endpos = _endpos_exp_ in let _v : (Parsetree.pattern * Parsetree.expression) = -# 2746 "src/ocaml/preprocess/parser_raw.mly" +# 2854 "src/ocaml/preprocess/parser_raw.mly" ( let loc = (_startpos_pat_, _endpos_typ_) in (ghpat ~loc (Ppat_constraint(pat, typ)), exp) ) -# 17079 "src/ocaml/preprocess/parser_raw.ml" +# 23332 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17112,9 +23365,9 @@ module Tables = struct let _startpos = _startpos_pat_ in let _endpos = _endpos_exp_ in let _v : (Parsetree.pattern * Parsetree.expression) = -# 2749 "src/ocaml/preprocess/parser_raw.mly" +# 2857 "src/ocaml/preprocess/parser_raw.mly" ( (pat, exp) ) -# 17118 "src/ocaml/preprocess/parser_raw.ml" +# 23371 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17137,10 +23390,10 @@ module Tables = struct let _startpos = _startpos_body_ in let _endpos = _endpos_body_ in let _v : (Parsetree.pattern * Parsetree.expression * Parsetree.binding_op list) = -# 2753 "src/ocaml/preprocess/parser_raw.mly" +# 2861 "src/ocaml/preprocess/parser_raw.mly" ( let let_pat, let_exp = body in let_pat, let_exp, [] ) -# 17144 "src/ocaml/preprocess/parser_raw.ml" +# 23397 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17172,9 +23425,9 @@ module Tables = struct } = _menhir_stack in let body : (Parsetree.pattern * Parsetree.expression) = Obj.magic body in let _1 : ( -# 776 "src/ocaml/preprocess/parser_raw.mly" +# 821 "src/ocaml/preprocess/parser_raw.mly" (string) -# 17178 "src/ocaml/preprocess/parser_raw.ml" +# 23431 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let bindings : (Parsetree.pattern * Parsetree.expression * Parsetree.binding_op list) = Obj.magic bindings in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -17185,22 +23438,22 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 17191 "src/ocaml/preprocess/parser_raw.ml" +# 23444 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_body_ in let _symbolstartpos = _startpos_bindings_ in let _sloc = (_symbolstartpos, _endpos) in -# 2756 "src/ocaml/preprocess/parser_raw.mly" +# 2864 "src/ocaml/preprocess/parser_raw.mly" ( let let_pat, let_exp, rev_ands = bindings in let pbop_pat, pbop_exp = body in let pbop_loc = make_loc _sloc in let and_ = {pbop_op; pbop_pat; pbop_exp; pbop_loc} in let_pat, let_exp, and_ :: rev_ands ) -# 17204 "src/ocaml/preprocess/parser_raw.ml" +# 23457 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17218,7 +23471,7 @@ module Tables = struct let _v : (Parsetree.class_expr Parsetree.class_infos list) = # 211 "" ( [] ) -# 17222 "src/ocaml/preprocess/parser_raw.ml" +# 23475 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17282,9 +23535,9 @@ module Tables = struct let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in let body : (Parsetree.class_expr) = Obj.magic body in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 17288 "src/ocaml/preprocess/parser_raw.ml" +# 23541 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in let virt : (Asttypes.virtual_flag) = Obj.magic virt in @@ -17297,9 +23550,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 17303 "src/ocaml/preprocess/parser_raw.ml" +# 23556 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -17309,24 +23562,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 17315 "src/ocaml/preprocess/parser_raw.ml" +# 23568 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 17323 "src/ocaml/preprocess/parser_raw.ml" +# 23576 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1963 "src/ocaml/preprocess/parser_raw.mly" +# 2038 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in @@ -17334,13 +23587,13 @@ module Tables = struct let text = symbol_text _symbolstartpos in Ci.mk id body ~virt ~params ~attrs ~loc ~text ~docs ) -# 17338 "src/ocaml/preprocess/parser_raw.ml" +# 23591 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 17344 "src/ocaml/preprocess/parser_raw.ml" +# 23597 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17358,7 +23611,7 @@ module Tables = struct let _v : (Parsetree.class_type Parsetree.class_infos list) = # 211 "" ( [] ) -# 17362 "src/ocaml/preprocess/parser_raw.ml" +# 23615 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17429,9 +23682,9 @@ module Tables = struct let cty : (Parsetree.class_type) = Obj.magic cty in let _6 : unit = Obj.magic _6 in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 17435 "src/ocaml/preprocess/parser_raw.ml" +# 23688 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in let virt : (Asttypes.virtual_flag) = Obj.magic virt in @@ -17444,9 +23697,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 17450 "src/ocaml/preprocess/parser_raw.ml" +# 23703 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -17456,24 +23709,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 17462 "src/ocaml/preprocess/parser_raw.ml" +# 23715 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 17470 "src/ocaml/preprocess/parser_raw.ml" +# 23723 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2262 "src/ocaml/preprocess/parser_raw.mly" +# 2337 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in @@ -17481,13 +23734,13 @@ module Tables = struct let text = symbol_text _symbolstartpos in Ci.mk id cty ~virt ~params ~attrs ~loc ~text ~docs ) -# 17485 "src/ocaml/preprocess/parser_raw.ml" +# 23738 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 17491 "src/ocaml/preprocess/parser_raw.ml" +# 23744 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17505,7 +23758,7 @@ module Tables = struct let _v : (Parsetree.class_type Parsetree.class_infos list) = # 211 "" ( [] ) -# 17509 "src/ocaml/preprocess/parser_raw.ml" +# 23762 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17576,9 +23829,9 @@ module Tables = struct let csig : (Parsetree.class_type) = Obj.magic csig in let _6 : unit = Obj.magic _6 in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 17582 "src/ocaml/preprocess/parser_raw.ml" +# 23835 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in let virt : (Asttypes.virtual_flag) = Obj.magic virt in @@ -17591,9 +23844,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 17597 "src/ocaml/preprocess/parser_raw.ml" +# 23850 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -17603,24 +23856,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 17609 "src/ocaml/preprocess/parser_raw.ml" +# 23862 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 17617 "src/ocaml/preprocess/parser_raw.ml" +# 23870 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2301 "src/ocaml/preprocess/parser_raw.mly" +# 2376 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in @@ -17628,13 +23881,13 @@ module Tables = struct let text = symbol_text _symbolstartpos in Ci.mk id csig ~virt ~params ~attrs ~loc ~text ~docs ) -# 17632 "src/ocaml/preprocess/parser_raw.ml" +# 23885 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 17638 "src/ocaml/preprocess/parser_raw.ml" +# 23891 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17652,7 +23905,7 @@ module Tables = struct let _v : (Parsetree.module_binding list) = # 211 "" ( [] ) -# 17656 "src/ocaml/preprocess/parser_raw.ml" +# 23909 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17713,9 +23966,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 17719 "src/ocaml/preprocess/parser_raw.ml" +# 23972 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -17725,24 +23978,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 17731 "src/ocaml/preprocess/parser_raw.ml" +# 23984 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 17739 "src/ocaml/preprocess/parser_raw.ml" +# 23992 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1619 "src/ocaml/preprocess/parser_raw.mly" +# 1684 "src/ocaml/preprocess/parser_raw.mly" ( let loc = make_loc _sloc in let attrs = attrs1 @ attrs2 in @@ -17750,13 +24003,13 @@ module Tables = struct let text = symbol_text _symbolstartpos in Mb.mk name body ~attrs ~loc ~text ~docs ) -# 17754 "src/ocaml/preprocess/parser_raw.ml" +# 24007 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 17760 "src/ocaml/preprocess/parser_raw.ml" +# 24013 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17774,7 +24027,7 @@ module Tables = struct let _v : (Parsetree.module_declaration list) = # 211 "" ( [] ) -# 17778 "src/ocaml/preprocess/parser_raw.ml" +# 24031 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17842,9 +24095,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 17848 "src/ocaml/preprocess/parser_raw.ml" +# 24101 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -17854,24 +24107,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 17860 "src/ocaml/preprocess/parser_raw.ml" +# 24113 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 17868 "src/ocaml/preprocess/parser_raw.ml" +# 24121 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1904 "src/ocaml/preprocess/parser_raw.mly" +# 1979 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let docs = symbol_docs _sloc in @@ -17879,13 +24132,13 @@ module Tables = struct let text = symbol_text _symbolstartpos in Md.mk name mty ~attrs ~loc ~text ~docs ) -# 17883 "src/ocaml/preprocess/parser_raw.ml" +# 24136 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 17889 "src/ocaml/preprocess/parser_raw.ml" +# 24142 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17903,7 +24156,7 @@ module Tables = struct let _v : (Parsetree.attributes) = # 211 "" ( [] ) -# 17907 "src/ocaml/preprocess/parser_raw.ml" +# 24160 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17935,7 +24188,7 @@ module Tables = struct let _v : (Parsetree.attributes) = # 213 "" ( x :: xs ) -# 17939 "src/ocaml/preprocess/parser_raw.ml" +# 24192 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -17953,7 +24206,7 @@ module Tables = struct let _v : (Parsetree.type_declaration list) = # 211 "" ( [] ) -# 17957 "src/ocaml/preprocess/parser_raw.ml" +# 24210 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18018,9 +24271,9 @@ module Tables = struct let xs_inlined1 : ((Parsetree.core_type * Parsetree.core_type * Location.t) list) = Obj.magic xs_inlined1 in let kind_priv_manifest : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic kind_priv_manifest in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 18024 "src/ocaml/preprocess/parser_raw.ml" +# 24277 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in @@ -18033,9 +24286,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 18039 "src/ocaml/preprocess/parser_raw.ml" +# 24292 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -18044,18 +24297,18 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 18048 "src/ocaml/preprocess/parser_raw.ml" +# 24301 "src/ocaml/preprocess/parser_raw.ml" in -# 1074 "src/ocaml/preprocess/parser_raw.mly" +# 1111 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 18053 "src/ocaml/preprocess/parser_raw.ml" +# 24306 "src/ocaml/preprocess/parser_raw.ml" in -# 3157 "src/ocaml/preprocess/parser_raw.mly" +# 3297 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 18059 "src/ocaml/preprocess/parser_raw.ml" +# 24312 "src/ocaml/preprocess/parser_raw.ml" in let id = @@ -18064,24 +24317,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 18070 "src/ocaml/preprocess/parser_raw.ml" +# 24323 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 18078 "src/ocaml/preprocess/parser_raw.ml" +# 24331 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3146 "src/ocaml/preprocess/parser_raw.mly" +# 3286 "src/ocaml/preprocess/parser_raw.mly" ( let (kind, priv, manifest) = kind_priv_manifest in let docs = symbol_docs _sloc in @@ -18090,13 +24343,13 @@ module Tables = struct let text = symbol_text _symbolstartpos in Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs ~text ) -# 18094 "src/ocaml/preprocess/parser_raw.ml" +# 24347 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 18100 "src/ocaml/preprocess/parser_raw.ml" +# 24353 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18114,7 +24367,7 @@ module Tables = struct let _v : (Parsetree.type_declaration list) = # 211 "" ( [] ) -# 18118 "src/ocaml/preprocess/parser_raw.ml" +# 24371 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18186,9 +24439,9 @@ module Tables = struct let _2 : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic _2 in let _1_inlined3 : unit = Obj.magic _1_inlined3 in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 18192 "src/ocaml/preprocess/parser_raw.ml" +# 24445 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in @@ -18201,9 +24454,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined4 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 18207 "src/ocaml/preprocess/parser_raw.ml" +# 24460 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined4_ in @@ -18212,26 +24465,26 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 18216 "src/ocaml/preprocess/parser_raw.ml" +# 24469 "src/ocaml/preprocess/parser_raw.ml" in -# 1074 "src/ocaml/preprocess/parser_raw.mly" +# 1111 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 18221 "src/ocaml/preprocess/parser_raw.ml" +# 24474 "src/ocaml/preprocess/parser_raw.ml" in -# 3157 "src/ocaml/preprocess/parser_raw.mly" +# 3297 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 18227 "src/ocaml/preprocess/parser_raw.ml" +# 24480 "src/ocaml/preprocess/parser_raw.ml" in let kind_priv_manifest = let _1 = _1_inlined3 in -# 3192 "src/ocaml/preprocess/parser_raw.mly" +# 3332 "src/ocaml/preprocess/parser_raw.mly" ( _2 ) -# 18235 "src/ocaml/preprocess/parser_raw.ml" +# 24488 "src/ocaml/preprocess/parser_raw.ml" in let id = @@ -18240,24 +24493,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 18246 "src/ocaml/preprocess/parser_raw.ml" +# 24499 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 18254 "src/ocaml/preprocess/parser_raw.ml" +# 24507 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3146 "src/ocaml/preprocess/parser_raw.mly" +# 3286 "src/ocaml/preprocess/parser_raw.mly" ( let (kind, priv, manifest) = kind_priv_manifest in let docs = symbol_docs _sloc in @@ -18266,13 +24519,13 @@ module Tables = struct let text = symbol_text _symbolstartpos in Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs ~text ) -# 18270 "src/ocaml/preprocess/parser_raw.ml" +# 24523 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 18276 "src/ocaml/preprocess/parser_raw.ml" +# 24529 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18290,7 +24543,7 @@ module Tables = struct let _v : (Parsetree.attributes) = # 211 "" ( [] ) -# 18294 "src/ocaml/preprocess/parser_raw.ml" +# 24547 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18322,7 +24575,7 @@ module Tables = struct let _v : (Parsetree.attributes) = # 213 "" ( x :: xs ) -# 18326 "src/ocaml/preprocess/parser_raw.ml" +# 24579 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18340,7 +24593,7 @@ module Tables = struct let _v : (Parsetree.signature_item list list) = # 211 "" ( [] ) -# 18344 "src/ocaml/preprocess/parser_raw.ml" +# 24597 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18373,21 +24626,21 @@ module Tables = struct let _1 = let _startpos = _startpos__1_ in -# 1000 "src/ocaml/preprocess/parser_raw.mly" +# 1037 "src/ocaml/preprocess/parser_raw.mly" ( text_sig _startpos ) -# 18379 "src/ocaml/preprocess/parser_raw.ml" +# 24632 "src/ocaml/preprocess/parser_raw.ml" in -# 1761 "src/ocaml/preprocess/parser_raw.mly" +# 1832 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 18385 "src/ocaml/preprocess/parser_raw.ml" +# 24638 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 18391 "src/ocaml/preprocess/parser_raw.ml" +# 24644 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18420,21 +24673,21 @@ module Tables = struct let _1 = let _startpos = _startpos__1_ in -# 998 "src/ocaml/preprocess/parser_raw.mly" +# 1035 "src/ocaml/preprocess/parser_raw.mly" ( text_sig _startpos @ [_1] ) -# 18426 "src/ocaml/preprocess/parser_raw.ml" +# 24679 "src/ocaml/preprocess/parser_raw.ml" in -# 1761 "src/ocaml/preprocess/parser_raw.mly" +# 1832 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 18432 "src/ocaml/preprocess/parser_raw.ml" +# 24685 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 18438 "src/ocaml/preprocess/parser_raw.ml" +# 24691 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18452,7 +24705,7 @@ module Tables = struct let _v : (Parsetree.structure_item list list) = # 211 "" ( [] ) -# 18456 "src/ocaml/preprocess/parser_raw.ml" +# 24709 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18485,40 +24738,40 @@ module Tables = struct let _1 = let ys = let items = -# 1060 "src/ocaml/preprocess/parser_raw.mly" +# 1097 "src/ocaml/preprocess/parser_raw.mly" ( [] ) -# 18491 "src/ocaml/preprocess/parser_raw.ml" +# 24744 "src/ocaml/preprocess/parser_raw.ml" in -# 1502 "src/ocaml/preprocess/parser_raw.mly" +# 1563 "src/ocaml/preprocess/parser_raw.mly" ( items ) -# 18496 "src/ocaml/preprocess/parser_raw.ml" +# 24749 "src/ocaml/preprocess/parser_raw.ml" in let xs = let _startpos = _startpos__1_ in -# 996 "src/ocaml/preprocess/parser_raw.mly" +# 1033 "src/ocaml/preprocess/parser_raw.mly" ( text_str _startpos ) -# 18504 "src/ocaml/preprocess/parser_raw.ml" +# 24757 "src/ocaml/preprocess/parser_raw.ml" in # 267 "" ( xs @ ys ) -# 18510 "src/ocaml/preprocess/parser_raw.ml" +# 24763 "src/ocaml/preprocess/parser_raw.ml" in -# 1518 "src/ocaml/preprocess/parser_raw.mly" +# 1579 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 18516 "src/ocaml/preprocess/parser_raw.ml" +# 24769 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 18522 "src/ocaml/preprocess/parser_raw.ml" +# 24775 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18570,70 +24823,70 @@ module Tables = struct let _1 = let _1 = let attrs = -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 18576 "src/ocaml/preprocess/parser_raw.ml" +# 24829 "src/ocaml/preprocess/parser_raw.ml" in -# 1509 "src/ocaml/preprocess/parser_raw.mly" +# 1570 "src/ocaml/preprocess/parser_raw.mly" ( mkstrexp e attrs ) -# 18581 "src/ocaml/preprocess/parser_raw.ml" +# 24834 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__1_ = _startpos_e_ in let _startpos = _startpos__1_ in -# 994 "src/ocaml/preprocess/parser_raw.mly" +# 1031 "src/ocaml/preprocess/parser_raw.mly" ( text_str _startpos @ [_1] ) -# 18589 "src/ocaml/preprocess/parser_raw.ml" +# 24842 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__1_ = _startpos_e_ in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 1013 "src/ocaml/preprocess/parser_raw.mly" +# 1050 "src/ocaml/preprocess/parser_raw.mly" ( mark_rhs_docs _startpos _endpos; _1 ) -# 18599 "src/ocaml/preprocess/parser_raw.ml" +# 24852 "src/ocaml/preprocess/parser_raw.ml" in -# 1062 "src/ocaml/preprocess/parser_raw.mly" +# 1099 "src/ocaml/preprocess/parser_raw.mly" ( x ) -# 18605 "src/ocaml/preprocess/parser_raw.ml" +# 24858 "src/ocaml/preprocess/parser_raw.ml" in -# 1502 "src/ocaml/preprocess/parser_raw.mly" +# 1563 "src/ocaml/preprocess/parser_raw.mly" ( items ) -# 18611 "src/ocaml/preprocess/parser_raw.ml" +# 24864 "src/ocaml/preprocess/parser_raw.ml" in let xs = let _startpos = _startpos__1_ in -# 996 "src/ocaml/preprocess/parser_raw.mly" +# 1033 "src/ocaml/preprocess/parser_raw.mly" ( text_str _startpos ) -# 18619 "src/ocaml/preprocess/parser_raw.ml" +# 24872 "src/ocaml/preprocess/parser_raw.ml" in # 267 "" ( xs @ ys ) -# 18625 "src/ocaml/preprocess/parser_raw.ml" +# 24878 "src/ocaml/preprocess/parser_raw.ml" in -# 1518 "src/ocaml/preprocess/parser_raw.mly" +# 1579 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 18631 "src/ocaml/preprocess/parser_raw.ml" +# 24884 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 18637 "src/ocaml/preprocess/parser_raw.ml" +# 24890 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18666,21 +24919,21 @@ module Tables = struct let _1 = let _startpos = _startpos__1_ in -# 994 "src/ocaml/preprocess/parser_raw.mly" +# 1031 "src/ocaml/preprocess/parser_raw.mly" ( text_str _startpos @ [_1] ) -# 18672 "src/ocaml/preprocess/parser_raw.ml" +# 24925 "src/ocaml/preprocess/parser_raw.ml" in -# 1518 "src/ocaml/preprocess/parser_raw.mly" +# 1579 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 18678 "src/ocaml/preprocess/parser_raw.ml" +# 24931 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 18684 "src/ocaml/preprocess/parser_raw.ml" +# 24937 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18698,7 +24951,7 @@ module Tables = struct let _v : (Parsetree.class_type_field list list) = # 211 "" ( [] ) -# 18702 "src/ocaml/preprocess/parser_raw.ml" +# 24955 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18730,15 +24983,15 @@ module Tables = struct let _v : (Parsetree.class_type_field list list) = let x = let _startpos = _startpos__1_ in -# 1008 "src/ocaml/preprocess/parser_raw.mly" +# 1045 "src/ocaml/preprocess/parser_raw.mly" ( text_csig _startpos @ [_1] ) -# 18736 "src/ocaml/preprocess/parser_raw.ml" +# 24989 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 18742 "src/ocaml/preprocess/parser_raw.ml" +# 24995 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18756,7 +25009,7 @@ module Tables = struct let _v : (Parsetree.class_field list list) = # 211 "" ( [] ) -# 18760 "src/ocaml/preprocess/parser_raw.ml" +# 25013 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18788,15 +25041,15 @@ module Tables = struct let _v : (Parsetree.class_field list list) = let x = let _startpos = _startpos__1_ in -# 1006 "src/ocaml/preprocess/parser_raw.mly" +# 1043 "src/ocaml/preprocess/parser_raw.mly" ( text_cstr _startpos @ [_1] ) -# 18794 "src/ocaml/preprocess/parser_raw.ml" +# 25047 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 18800 "src/ocaml/preprocess/parser_raw.ml" +# 25053 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18814,7 +25067,7 @@ module Tables = struct let _v : (Parsetree.structure_item list list) = # 211 "" ( [] ) -# 18818 "src/ocaml/preprocess/parser_raw.ml" +# 25071 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18846,15 +25099,15 @@ module Tables = struct let _v : (Parsetree.structure_item list list) = let x = let _startpos = _startpos__1_ in -# 994 "src/ocaml/preprocess/parser_raw.mly" +# 1031 "src/ocaml/preprocess/parser_raw.mly" ( text_str _startpos @ [_1] ) -# 18852 "src/ocaml/preprocess/parser_raw.ml" +# 25105 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 18858 "src/ocaml/preprocess/parser_raw.ml" +# 25111 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18872,7 +25125,7 @@ module Tables = struct let _v : (Parsetree.toplevel_phrase list list) = # 211 "" ( [] ) -# 18876 "src/ocaml/preprocess/parser_raw.ml" +# 25129 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18905,32 +25158,32 @@ module Tables = struct let _1 = let x = let _1 = -# 1060 "src/ocaml/preprocess/parser_raw.mly" +# 1097 "src/ocaml/preprocess/parser_raw.mly" ( [] ) -# 18911 "src/ocaml/preprocess/parser_raw.ml" +# 25164 "src/ocaml/preprocess/parser_raw.ml" in -# 1292 "src/ocaml/preprocess/parser_raw.mly" +# 1350 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 18916 "src/ocaml/preprocess/parser_raw.ml" +# 25169 "src/ocaml/preprocess/parser_raw.ml" in # 183 "" ( x ) -# 18922 "src/ocaml/preprocess/parser_raw.ml" +# 25175 "src/ocaml/preprocess/parser_raw.ml" in -# 1304 "src/ocaml/preprocess/parser_raw.mly" +# 1362 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 18928 "src/ocaml/preprocess/parser_raw.ml" +# 25181 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 18934 "src/ocaml/preprocess/parser_raw.ml" +# 25187 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -18982,58 +25235,58 @@ module Tables = struct let _1 = let _1 = let attrs = -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 18988 "src/ocaml/preprocess/parser_raw.ml" +# 25241 "src/ocaml/preprocess/parser_raw.ml" in -# 1509 "src/ocaml/preprocess/parser_raw.mly" +# 1570 "src/ocaml/preprocess/parser_raw.mly" ( mkstrexp e attrs ) -# 18993 "src/ocaml/preprocess/parser_raw.ml" +# 25246 "src/ocaml/preprocess/parser_raw.ml" in -# 1004 "src/ocaml/preprocess/parser_raw.mly" +# 1041 "src/ocaml/preprocess/parser_raw.mly" ( Ptop_def [_1] ) -# 18999 "src/ocaml/preprocess/parser_raw.ml" +# 25252 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__1_ = _startpos_e_ in let _startpos = _startpos__1_ in -# 1002 "src/ocaml/preprocess/parser_raw.mly" +# 1039 "src/ocaml/preprocess/parser_raw.mly" ( text_def _startpos @ [_1] ) -# 19007 "src/ocaml/preprocess/parser_raw.ml" +# 25260 "src/ocaml/preprocess/parser_raw.ml" in -# 1062 "src/ocaml/preprocess/parser_raw.mly" +# 1099 "src/ocaml/preprocess/parser_raw.mly" ( x ) -# 19013 "src/ocaml/preprocess/parser_raw.ml" +# 25266 "src/ocaml/preprocess/parser_raw.ml" in -# 1292 "src/ocaml/preprocess/parser_raw.mly" +# 1350 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 19019 "src/ocaml/preprocess/parser_raw.ml" +# 25272 "src/ocaml/preprocess/parser_raw.ml" in # 183 "" ( x ) -# 19025 "src/ocaml/preprocess/parser_raw.ml" +# 25278 "src/ocaml/preprocess/parser_raw.ml" in -# 1304 "src/ocaml/preprocess/parser_raw.mly" +# 1362 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 19031 "src/ocaml/preprocess/parser_raw.ml" +# 25284 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 19037 "src/ocaml/preprocess/parser_raw.ml" +# 25290 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19065,27 +25318,27 @@ module Tables = struct let _v : (Parsetree.toplevel_phrase list list) = let x = let _1 = let _1 = -# 1004 "src/ocaml/preprocess/parser_raw.mly" +# 1041 "src/ocaml/preprocess/parser_raw.mly" ( Ptop_def [_1] ) -# 19071 "src/ocaml/preprocess/parser_raw.ml" +# 25324 "src/ocaml/preprocess/parser_raw.ml" in let _startpos = _startpos__1_ in -# 1002 "src/ocaml/preprocess/parser_raw.mly" +# 1039 "src/ocaml/preprocess/parser_raw.mly" ( text_def _startpos @ [_1] ) -# 19077 "src/ocaml/preprocess/parser_raw.ml" +# 25330 "src/ocaml/preprocess/parser_raw.ml" in -# 1304 "src/ocaml/preprocess/parser_raw.mly" +# 1362 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 19083 "src/ocaml/preprocess/parser_raw.ml" +# 25336 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 19089 "src/ocaml/preprocess/parser_raw.ml" +# 25342 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19120,29 +25373,29 @@ module Tables = struct let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 1013 "src/ocaml/preprocess/parser_raw.mly" +# 1050 "src/ocaml/preprocess/parser_raw.mly" ( mark_rhs_docs _startpos _endpos; _1 ) -# 19127 "src/ocaml/preprocess/parser_raw.ml" +# 25380 "src/ocaml/preprocess/parser_raw.ml" in let _startpos = _startpos__1_ in -# 1002 "src/ocaml/preprocess/parser_raw.mly" +# 1039 "src/ocaml/preprocess/parser_raw.mly" ( text_def _startpos @ [_1] ) -# 19134 "src/ocaml/preprocess/parser_raw.ml" +# 25387 "src/ocaml/preprocess/parser_raw.ml" in -# 1304 "src/ocaml/preprocess/parser_raw.mly" +# 1362 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 19140 "src/ocaml/preprocess/parser_raw.ml" +# 25393 "src/ocaml/preprocess/parser_raw.ml" in # 213 "" ( x :: xs ) -# 19146 "src/ocaml/preprocess/parser_raw.ml" +# 25399 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19181,7 +25434,7 @@ module Tables = struct let _v : ((Longident.t Location.loc * Parsetree.pattern) list * unit option) = let _2 = # 124 "" ( None ) -# 19185 "src/ocaml/preprocess/parser_raw.ml" +# 25438 "src/ocaml/preprocess/parser_raw.ml" in let x = let label = @@ -19189,9 +25442,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 19195 "src/ocaml/preprocess/parser_raw.ml" +# 25448 "src/ocaml/preprocess/parser_raw.ml" in let _startpos_label_ = _startpos__1_ in @@ -19199,7 +25452,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 3032 "src/ocaml/preprocess/parser_raw.mly" +# 3172 "src/ocaml/preprocess/parser_raw.mly" ( let constraint_loc, label, pat = match opat with | None -> @@ -19213,13 +25466,13 @@ module Tables = struct in label, mkpat_opt_constraint ~loc:constraint_loc pat octy ) -# 19217 "src/ocaml/preprocess/parser_raw.ml" +# 25470 "src/ocaml/preprocess/parser_raw.ml" in -# 1229 "src/ocaml/preprocess/parser_raw.mly" +# 1287 "src/ocaml/preprocess/parser_raw.mly" ( [x], None ) -# 19223 "src/ocaml/preprocess/parser_raw.ml" +# 25476 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19265,7 +25518,7 @@ module Tables = struct let _v : ((Longident.t Location.loc * Parsetree.pattern) list * unit option) = let _2 = # 126 "" ( Some x ) -# 19269 "src/ocaml/preprocess/parser_raw.ml" +# 25522 "src/ocaml/preprocess/parser_raw.ml" in let x = let label = @@ -19273,9 +25526,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 19279 "src/ocaml/preprocess/parser_raw.ml" +# 25532 "src/ocaml/preprocess/parser_raw.ml" in let _startpos_label_ = _startpos__1_ in @@ -19283,7 +25536,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 3032 "src/ocaml/preprocess/parser_raw.mly" +# 3172 "src/ocaml/preprocess/parser_raw.mly" ( let constraint_loc, label, pat = match opat with | None -> @@ -19297,13 +25550,13 @@ module Tables = struct in label, mkpat_opt_constraint ~loc:constraint_loc pat octy ) -# 19301 "src/ocaml/preprocess/parser_raw.ml" +# 25554 "src/ocaml/preprocess/parser_raw.ml" in -# 1229 "src/ocaml/preprocess/parser_raw.mly" +# 1287 "src/ocaml/preprocess/parser_raw.mly" ( [x], None ) -# 19307 "src/ocaml/preprocess/parser_raw.ml" +# 25560 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19366,9 +25619,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 19372 "src/ocaml/preprocess/parser_raw.ml" +# 25625 "src/ocaml/preprocess/parser_raw.ml" in let _startpos_label_ = _startpos__1_ in @@ -19376,7 +25629,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 3032 "src/ocaml/preprocess/parser_raw.mly" +# 3172 "src/ocaml/preprocess/parser_raw.mly" ( let constraint_loc, label, pat = match opat with | None -> @@ -19390,13 +25643,13 @@ module Tables = struct in label, mkpat_opt_constraint ~loc:constraint_loc pat octy ) -# 19394 "src/ocaml/preprocess/parser_raw.ml" +# 25647 "src/ocaml/preprocess/parser_raw.ml" in -# 1231 "src/ocaml/preprocess/parser_raw.mly" +# 1289 "src/ocaml/preprocess/parser_raw.mly" ( [x], Some y ) -# 19400 "src/ocaml/preprocess/parser_raw.ml" +# 25653 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19452,9 +25705,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 19458 "src/ocaml/preprocess/parser_raw.ml" +# 25711 "src/ocaml/preprocess/parser_raw.ml" in let _startpos_label_ = _startpos__1_ in @@ -19462,7 +25715,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 3032 "src/ocaml/preprocess/parser_raw.mly" +# 3172 "src/ocaml/preprocess/parser_raw.mly" ( let constraint_loc, label, pat = match opat with | None -> @@ -19476,157 +25729,14 @@ module Tables = struct in label, mkpat_opt_constraint ~loc:constraint_loc pat octy ) -# 19480 "src/ocaml/preprocess/parser_raw.ml" +# 25733 "src/ocaml/preprocess/parser_raw.ml" in -# 1235 "src/ocaml/preprocess/parser_raw.mly" +# 1293 "src/ocaml/preprocess/parser_raw.mly" ( let xs, y = tail in x :: xs, y ) -# 19487 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined3; - MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - }; - }; - } = _menhir_stack in - let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in - let _4 : (Parsetree.pattern * Parsetree.expression * bool) = Obj.magic _4 in - let _3 : (Asttypes.rec_flag) = Obj.magic _3 in - let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in - let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__1_inlined3_ in - let _v : (Ast_helper.let_bindings) = let _5 = - let _1 = _1_inlined3 in - -# 4027 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 19549 "src/ocaml/preprocess/parser_raw.ml" - - in - let _2 = - let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in - let _2 = - let _1 = _1_inlined1 in - -# 4031 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 19559 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 4044 "src/ocaml/preprocess/parser_raw.mly" - ( _1, _2 ) -# 19565 "src/ocaml/preprocess/parser_raw.ml" - - in - let _loc__4_ = (_startpos__4_, _endpos__4_) in - -# 4078 "src/ocaml/preprocess/parser_raw.mly" - ( let (ext, attr) = _2 in - mklbs ext _3 (mklb ~loc:_loc__4_ true _4 (attr@_5)) ) -# 19573 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - } = _menhir_stack in - let _1 : (Ast_helper.let_bindings) = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__1_ in - let _v : (Ast_helper.let_bindings) = -# 4082 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 19598 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - } = _menhir_stack in - let _2 : (Ast_helper.let_binding) = Obj.magic _2 in - let _1 : (Ast_helper.let_bindings) = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__2_ in - let _v : (Ast_helper.let_bindings) = -# 4083 "src/ocaml/preprocess/parser_raw.mly" - ( addlb _1 _2 ) -# 19630 "src/ocaml/preprocess/parser_raw.ml" +# 25740 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19663,9 +25773,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.case) = -# 2782 "src/ocaml/preprocess/parser_raw.mly" +# 2897 "src/ocaml/preprocess/parser_raw.mly" ( Exp.case _1 (merloc _endpos__2_ _3) ) -# 19669 "src/ocaml/preprocess/parser_raw.ml" +# 25779 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19716,9 +25826,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in let _v : (Parsetree.case) = -# 2784 "src/ocaml/preprocess/parser_raw.mly" +# 2899 "src/ocaml/preprocess/parser_raw.mly" ( Exp.case _1 ~guard:(merloc _endpos__2_ _3) (merloc _endpos__4_ _5) ) -# 19722 "src/ocaml/preprocess/parser_raw.ml" +# 25832 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19756,10 +25866,10 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Parsetree.case) = let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2786 "src/ocaml/preprocess/parser_raw.mly" +# 2901 "src/ocaml/preprocess/parser_raw.mly" ( Exp.case _1 (merloc _endpos__2_ (Exp.unreachable ~loc:(make_loc _loc__3_) ())) ) -# 19763 "src/ocaml/preprocess/parser_raw.ml" +# 25873 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19820,9 +25930,9 @@ module Tables = struct let _1_inlined1 : (Parsetree.core_type) = Obj.magic _1_inlined1 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 19826 "src/ocaml/preprocess/parser_raw.ml" +# 25936 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -19831,49 +25941,49 @@ module Tables = struct let _6 = let _1 = _1_inlined3 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 19837 "src/ocaml/preprocess/parser_raw.ml" +# 25947 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__6_ = _endpos__1_inlined3_ in let _4 = let _1 = _1_inlined2 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 19846 "src/ocaml/preprocess/parser_raw.ml" +# 25956 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__4_ = _endpos__1_inlined2_ in let _3 = let _1 = _1_inlined1 in -# 3460 "src/ocaml/preprocess/parser_raw.mly" +# 3600 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 19855 "src/ocaml/preprocess/parser_raw.ml" +# 25965 "src/ocaml/preprocess/parser_raw.ml" in let _1 = let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 19862 "src/ocaml/preprocess/parser_raw.ml" +# 25972 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 19870 "src/ocaml/preprocess/parser_raw.ml" +# 25980 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__6_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3670 "src/ocaml/preprocess/parser_raw.mly" +# 3866 "src/ocaml/preprocess/parser_raw.mly" ( let info = match rhs_info _endpos__4_ with | Some _ as info_before_semi -> info_before_semi @@ -19881,13 +25991,13 @@ module Tables = struct in let attrs = add_info_attrs info (_4 @ _6) in Of.tag ~loc:(make_loc _sloc) ~attrs _1 _3 ) -# 19885 "src/ocaml/preprocess/parser_raw.ml" +# 25995 "src/ocaml/preprocess/parser_raw.ml" in -# 3651 "src/ocaml/preprocess/parser_raw.mly" +# 3847 "src/ocaml/preprocess/parser_raw.mly" ( let (f, c) = tail in (head :: f, c) ) -# 19891 "src/ocaml/preprocess/parser_raw.ml" +# 26001 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19928,15 +26038,15 @@ module Tables = struct let _symbolstartpos = _startpos_ty_ in let _sloc = (_symbolstartpos, _endpos) in -# 3681 "src/ocaml/preprocess/parser_raw.mly" +# 3877 "src/ocaml/preprocess/parser_raw.mly" ( Of.inherit_ ~loc:(make_loc _sloc) ty ) -# 19934 "src/ocaml/preprocess/parser_raw.ml" +# 26044 "src/ocaml/preprocess/parser_raw.ml" in -# 3651 "src/ocaml/preprocess/parser_raw.mly" +# 3847 "src/ocaml/preprocess/parser_raw.mly" ( let (f, c) = tail in (head :: f, c) ) -# 19940 "src/ocaml/preprocess/parser_raw.ml" +# 26050 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -19990,9 +26100,9 @@ module Tables = struct let _1_inlined1 : (Parsetree.core_type) = Obj.magic _1_inlined1 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 19996 "src/ocaml/preprocess/parser_raw.ml" +# 26106 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -20001,49 +26111,49 @@ module Tables = struct let _6 = let _1 = _1_inlined3 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20007 "src/ocaml/preprocess/parser_raw.ml" +# 26117 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__6_ = _endpos__1_inlined3_ in let _4 = let _1 = _1_inlined2 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20016 "src/ocaml/preprocess/parser_raw.ml" +# 26126 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__4_ = _endpos__1_inlined2_ in let _3 = let _1 = _1_inlined1 in -# 3460 "src/ocaml/preprocess/parser_raw.mly" +# 3600 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20025 "src/ocaml/preprocess/parser_raw.ml" +# 26135 "src/ocaml/preprocess/parser_raw.ml" in let _1 = let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20032 "src/ocaml/preprocess/parser_raw.ml" +# 26142 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 20040 "src/ocaml/preprocess/parser_raw.ml" +# 26150 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__6_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3670 "src/ocaml/preprocess/parser_raw.mly" +# 3866 "src/ocaml/preprocess/parser_raw.mly" ( let info = match rhs_info _endpos__4_ with | Some _ as info_before_semi -> info_before_semi @@ -20051,13 +26161,13 @@ module Tables = struct in let attrs = add_info_attrs info (_4 @ _6) in Of.tag ~loc:(make_loc _sloc) ~attrs _1 _3 ) -# 20055 "src/ocaml/preprocess/parser_raw.ml" +# 26165 "src/ocaml/preprocess/parser_raw.ml" in -# 3654 "src/ocaml/preprocess/parser_raw.mly" +# 3850 "src/ocaml/preprocess/parser_raw.mly" ( [head], Closed ) -# 20061 "src/ocaml/preprocess/parser_raw.ml" +# 26171 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20091,15 +26201,15 @@ module Tables = struct let _symbolstartpos = _startpos_ty_ in let _sloc = (_symbolstartpos, _endpos) in -# 3681 "src/ocaml/preprocess/parser_raw.mly" +# 3877 "src/ocaml/preprocess/parser_raw.mly" ( Of.inherit_ ~loc:(make_loc _sloc) ty ) -# 20097 "src/ocaml/preprocess/parser_raw.ml" +# 26207 "src/ocaml/preprocess/parser_raw.ml" in -# 3654 "src/ocaml/preprocess/parser_raw.mly" +# 3850 "src/ocaml/preprocess/parser_raw.mly" ( [head], Closed ) -# 20103 "src/ocaml/preprocess/parser_raw.ml" +# 26213 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20139,9 +26249,9 @@ module Tables = struct let _1_inlined1 : (Parsetree.core_type) = Obj.magic _1_inlined1 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 20145 "src/ocaml/preprocess/parser_raw.ml" +# 26255 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -20150,50 +26260,50 @@ module Tables = struct let _4 = let _1 = _1_inlined2 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20156 "src/ocaml/preprocess/parser_raw.ml" +# 26266 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__4_ = _endpos__1_inlined2_ in let _3 = let _1 = _1_inlined1 in -# 3460 "src/ocaml/preprocess/parser_raw.mly" +# 3600 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20165 "src/ocaml/preprocess/parser_raw.ml" +# 26275 "src/ocaml/preprocess/parser_raw.ml" in let _1 = let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20172 "src/ocaml/preprocess/parser_raw.ml" +# 26282 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 20180 "src/ocaml/preprocess/parser_raw.ml" +# 26290 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3663 "src/ocaml/preprocess/parser_raw.mly" +# 3859 "src/ocaml/preprocess/parser_raw.mly" ( let info = symbol_info _endpos in let attrs = add_info_attrs info _4 in Of.tag ~loc:(make_loc _sloc) ~attrs _1 _3 ) -# 20191 "src/ocaml/preprocess/parser_raw.ml" +# 26301 "src/ocaml/preprocess/parser_raw.ml" in -# 3657 "src/ocaml/preprocess/parser_raw.mly" +# 3853 "src/ocaml/preprocess/parser_raw.mly" ( [head], Closed ) -# 20197 "src/ocaml/preprocess/parser_raw.ml" +# 26307 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20220,15 +26330,15 @@ module Tables = struct let _symbolstartpos = _startpos_ty_ in let _sloc = (_symbolstartpos, _endpos) in -# 3681 "src/ocaml/preprocess/parser_raw.mly" +# 3877 "src/ocaml/preprocess/parser_raw.mly" ( Of.inherit_ ~loc:(make_loc _sloc) ty ) -# 20226 "src/ocaml/preprocess/parser_raw.ml" +# 26336 "src/ocaml/preprocess/parser_raw.ml" in -# 3657 "src/ocaml/preprocess/parser_raw.mly" +# 3853 "src/ocaml/preprocess/parser_raw.mly" ( [head], Closed ) -# 20232 "src/ocaml/preprocess/parser_raw.ml" +# 26342 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20251,9 +26361,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.object_field list * Asttypes.closed_flag) = -# 3659 "src/ocaml/preprocess/parser_raw.mly" +# 3855 "src/ocaml/preprocess/parser_raw.mly" ( [], Open ) -# 20257 "src/ocaml/preprocess/parser_raw.ml" +# 26367 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20298,9 +26408,9 @@ module Tables = struct let _1_inlined2 : (Parsetree.core_type) = Obj.magic _1_inlined2 in let _5 : unit = Obj.magic _5 in let _1_inlined1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 20304 "src/ocaml/preprocess/parser_raw.ml" +# 26414 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined1 in let private_ : (Asttypes.private_flag) = Obj.magic private_ in let _1 : (Parsetree.attributes) = Obj.magic _1 in @@ -20311,41 +26421,41 @@ module Tables = struct Parsetree.attributes) = let ty = let _1 = _1_inlined2 in -# 3456 "src/ocaml/preprocess/parser_raw.mly" +# 3596 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20317 "src/ocaml/preprocess/parser_raw.ml" +# 26427 "src/ocaml/preprocess/parser_raw.ml" in let label = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20325 "src/ocaml/preprocess/parser_raw.ml" +# 26435 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 20333 "src/ocaml/preprocess/parser_raw.ml" +# 26443 "src/ocaml/preprocess/parser_raw.ml" in let attrs = -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20339 "src/ocaml/preprocess/parser_raw.ml" +# 26449 "src/ocaml/preprocess/parser_raw.ml" in let _1 = -# 3930 "src/ocaml/preprocess/parser_raw.mly" +# 4126 "src/ocaml/preprocess/parser_raw.mly" ( Fresh ) -# 20344 "src/ocaml/preprocess/parser_raw.ml" +# 26454 "src/ocaml/preprocess/parser_raw.ml" in -# 2107 "src/ocaml/preprocess/parser_raw.mly" +# 2182 "src/ocaml/preprocess/parser_raw.mly" ( (label, private_, Cfk_virtual ty), attrs ) -# 20349 "src/ocaml/preprocess/parser_raw.ml" +# 26459 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20383,9 +26493,9 @@ module Tables = struct } = _menhir_stack in let _5 : (Parsetree.expression) = Obj.magic _5 in let _1_inlined1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 20389 "src/ocaml/preprocess/parser_raw.ml" +# 26499 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined1 in let _3 : (Asttypes.private_flag) = Obj.magic _3 in let _1 : (Parsetree.attributes) = Obj.magic _1 in @@ -20396,36 +26506,36 @@ module Tables = struct Parsetree.attributes) = let _4 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20402 "src/ocaml/preprocess/parser_raw.ml" +# 26512 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 20410 "src/ocaml/preprocess/parser_raw.ml" +# 26520 "src/ocaml/preprocess/parser_raw.ml" in let _2 = -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20416 "src/ocaml/preprocess/parser_raw.ml" +# 26526 "src/ocaml/preprocess/parser_raw.ml" in let _1 = -# 3933 "src/ocaml/preprocess/parser_raw.mly" +# 4129 "src/ocaml/preprocess/parser_raw.mly" ( Fresh ) -# 20421 "src/ocaml/preprocess/parser_raw.ml" +# 26531 "src/ocaml/preprocess/parser_raw.ml" in -# 2109 "src/ocaml/preprocess/parser_raw.mly" +# 2184 "src/ocaml/preprocess/parser_raw.mly" ( let e = _5 in let loc = Location.(e.pexp_loc.loc_start, e.pexp_loc.loc_end) in (_4, _3, Cfk_concrete (_1, ghexp ~loc (Pexp_poly (e, None)))), _2 ) -# 20429 "src/ocaml/preprocess/parser_raw.ml" +# 26539 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20469,9 +26579,9 @@ module Tables = struct } = _menhir_stack in let _5 : (Parsetree.expression) = Obj.magic _5 in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 20475 "src/ocaml/preprocess/parser_raw.ml" +# 26585 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let _3 : (Asttypes.private_flag) = Obj.magic _3 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in @@ -20483,39 +26593,39 @@ module Tables = struct Parsetree.attributes) = let _4 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20489 "src/ocaml/preprocess/parser_raw.ml" +# 26599 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 20497 "src/ocaml/preprocess/parser_raw.ml" +# 26607 "src/ocaml/preprocess/parser_raw.ml" in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20505 "src/ocaml/preprocess/parser_raw.ml" +# 26615 "src/ocaml/preprocess/parser_raw.ml" in let _1 = -# 3934 "src/ocaml/preprocess/parser_raw.mly" +# 4130 "src/ocaml/preprocess/parser_raw.mly" ( Override ) -# 20511 "src/ocaml/preprocess/parser_raw.ml" +# 26621 "src/ocaml/preprocess/parser_raw.ml" in -# 2109 "src/ocaml/preprocess/parser_raw.mly" +# 2184 "src/ocaml/preprocess/parser_raw.mly" ( let e = _5 in let loc = Location.(e.pexp_loc.loc_start, e.pexp_loc.loc_end) in (_4, _3, Cfk_concrete (_1, ghexp ~loc (Pexp_poly (e, None)))), _2 ) -# 20519 "src/ocaml/preprocess/parser_raw.ml" +# 26629 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20574,9 +26684,9 @@ module Tables = struct let _1_inlined2 : (Parsetree.core_type) = Obj.magic _1_inlined2 in let _5 : unit = Obj.magic _5 in let _1_inlined1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 20580 "src/ocaml/preprocess/parser_raw.ml" +# 26690 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined1 in let _3 : (Asttypes.private_flag) = Obj.magic _3 in let _1 : (Parsetree.attributes) = Obj.magic _1 in @@ -20587,45 +26697,45 @@ module Tables = struct Parsetree.attributes) = let _6 = let _1 = _1_inlined2 in -# 3456 "src/ocaml/preprocess/parser_raw.mly" +# 3596 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20593 "src/ocaml/preprocess/parser_raw.ml" +# 26703 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__6_ = _startpos__1_inlined2_ in let _4 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20602 "src/ocaml/preprocess/parser_raw.ml" +# 26712 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 20610 "src/ocaml/preprocess/parser_raw.ml" +# 26720 "src/ocaml/preprocess/parser_raw.ml" in let _2 = -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20616 "src/ocaml/preprocess/parser_raw.ml" +# 26726 "src/ocaml/preprocess/parser_raw.ml" in let _1 = -# 3933 "src/ocaml/preprocess/parser_raw.mly" +# 4129 "src/ocaml/preprocess/parser_raw.mly" ( Fresh ) -# 20621 "src/ocaml/preprocess/parser_raw.ml" +# 26731 "src/ocaml/preprocess/parser_raw.ml" in -# 2115 "src/ocaml/preprocess/parser_raw.mly" +# 2190 "src/ocaml/preprocess/parser_raw.mly" ( let poly_exp = let loc = (_startpos__6_, _endpos__8_) in ghexp ~loc (Pexp_poly(_8, Some _6)) in (_4, _3, Cfk_concrete (_1, poly_exp)), _2 ) -# 20629 "src/ocaml/preprocess/parser_raw.ml" +# 26739 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20690,9 +26800,9 @@ module Tables = struct let _1_inlined3 : (Parsetree.core_type) = Obj.magic _1_inlined3 in let _5 : unit = Obj.magic _5 in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 20696 "src/ocaml/preprocess/parser_raw.ml" +# 26806 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let _3 : (Asttypes.private_flag) = Obj.magic _3 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in @@ -20704,48 +26814,48 @@ module Tables = struct Parsetree.attributes) = let _6 = let _1 = _1_inlined3 in -# 3456 "src/ocaml/preprocess/parser_raw.mly" +# 3596 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20710 "src/ocaml/preprocess/parser_raw.ml" +# 26820 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__6_ = _startpos__1_inlined3_ in let _4 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20719 "src/ocaml/preprocess/parser_raw.ml" +# 26829 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 20727 "src/ocaml/preprocess/parser_raw.ml" +# 26837 "src/ocaml/preprocess/parser_raw.ml" in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20735 "src/ocaml/preprocess/parser_raw.ml" +# 26845 "src/ocaml/preprocess/parser_raw.ml" in let _1 = -# 3934 "src/ocaml/preprocess/parser_raw.mly" +# 4130 "src/ocaml/preprocess/parser_raw.mly" ( Override ) -# 20741 "src/ocaml/preprocess/parser_raw.ml" +# 26851 "src/ocaml/preprocess/parser_raw.ml" in -# 2115 "src/ocaml/preprocess/parser_raw.mly" +# 2190 "src/ocaml/preprocess/parser_raw.mly" ( let poly_exp = let loc = (_startpos__6_, _endpos__8_) in ghexp ~loc (Pexp_poly(_8, Some _6)) in (_4, _3, Cfk_concrete (_1, poly_exp)), _2 ) -# 20749 "src/ocaml/preprocess/parser_raw.ml" +# 26859 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20825,9 +26935,9 @@ module Tables = struct let _6 : unit = Obj.magic _6 in let _5 : unit = Obj.magic _5 in let _1_inlined1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 20831 "src/ocaml/preprocess/parser_raw.ml" +# 26941 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined1 in let _3 : (Asttypes.private_flag) = Obj.magic _3 in let _1 : (Parsetree.attributes) = Obj.magic _1 in @@ -20836,38 +26946,38 @@ module Tables = struct let _endpos = _endpos__11_ in let _v : ((string Location.loc * Asttypes.private_flag * Parsetree.class_field_kind) * Parsetree.attributes) = let _7 = -# 2662 "src/ocaml/preprocess/parser_raw.mly" +# 2774 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 20842 "src/ocaml/preprocess/parser_raw.ml" +# 26952 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__7_ = _startpos_xs_ in let _4 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20850 "src/ocaml/preprocess/parser_raw.ml" +# 26960 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 20858 "src/ocaml/preprocess/parser_raw.ml" +# 26968 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__4_ = _startpos__1_inlined1_ in let _2 = -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 20865 "src/ocaml/preprocess/parser_raw.ml" +# 26975 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__2_, _startpos__2_) = (_endpos__1_, _startpos__1_) in let _1 = -# 3933 "src/ocaml/preprocess/parser_raw.mly" +# 4129 "src/ocaml/preprocess/parser_raw.mly" ( Fresh ) -# 20871 "src/ocaml/preprocess/parser_raw.ml" +# 26981 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos__0_, _endpos__0_) in let _endpos = _endpos__11_ in @@ -20883,7 +26993,7 @@ module Tables = struct _startpos__4_ in let _sloc = (_symbolstartpos, _endpos) in -# 2121 "src/ocaml/preprocess/parser_raw.mly" +# 2196 "src/ocaml/preprocess/parser_raw.mly" ( let poly_exp_loc = (_startpos__7_, _endpos__11_) in let poly_exp = let exp, poly = @@ -20894,7 +27004,7 @@ module Tables = struct ghexp ~loc:poly_exp_loc (Pexp_poly(exp, Some poly)) in (_4, _3, Cfk_concrete (_1, poly_exp)), _2 ) -# 20898 "src/ocaml/preprocess/parser_raw.ml" +# 27008 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -20980,9 +27090,9 @@ module Tables = struct let _6 : unit = Obj.magic _6 in let _5 : unit = Obj.magic _5 in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 20986 "src/ocaml/preprocess/parser_raw.ml" +# 27096 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let _3 : (Asttypes.private_flag) = Obj.magic _3 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in @@ -20992,41 +27102,41 @@ module Tables = struct let _endpos = _endpos__11_ in let _v : ((string Location.loc * Asttypes.private_flag * Parsetree.class_field_kind) * Parsetree.attributes) = let _7 = -# 2662 "src/ocaml/preprocess/parser_raw.mly" +# 2774 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 20998 "src/ocaml/preprocess/parser_raw.ml" +# 27108 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__7_ = _startpos_xs_ in let _4 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 21006 "src/ocaml/preprocess/parser_raw.ml" +# 27116 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 21014 "src/ocaml/preprocess/parser_raw.ml" +# 27124 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__4_ = _startpos__1_inlined2_ in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 21023 "src/ocaml/preprocess/parser_raw.ml" +# 27133 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__2_, _startpos__2_) = (_endpos__1_inlined1_, _startpos__1_inlined1_) in let _1 = -# 3934 "src/ocaml/preprocess/parser_raw.mly" +# 4130 "src/ocaml/preprocess/parser_raw.mly" ( Override ) -# 21030 "src/ocaml/preprocess/parser_raw.ml" +# 27140 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__11_ in let _symbolstartpos = if _startpos__1_ != _endpos__1_ then @@ -21041,7 +27151,7 @@ module Tables = struct _startpos__4_ in let _sloc = (_symbolstartpos, _endpos) in -# 2121 "src/ocaml/preprocess/parser_raw.mly" +# 2196 "src/ocaml/preprocess/parser_raw.mly" ( let poly_exp_loc = (_startpos__7_, _endpos__11_) in let poly_exp = let exp, poly = @@ -21052,7 +27162,7 @@ module Tables = struct ghexp ~loc:poly_exp_loc (Pexp_poly(exp, Some poly)) in (_4, _3, Cfk_concrete (_1, poly_exp)), _2 ) -# 21056 "src/ocaml/preprocess/parser_raw.ml" +# 27166 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21071,17 +27181,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 21077 "src/ocaml/preprocess/parser_raw.ml" +# 27187 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3784 "src/ocaml/preprocess/parser_raw.mly" +# 3980 "src/ocaml/preprocess/parser_raw.mly" ( Lident _1 ) -# 21085 "src/ocaml/preprocess/parser_raw.ml" +# 27195 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21112,9 +27222,9 @@ module Tables = struct }; } = _menhir_stack in let _3 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 21118 "src/ocaml/preprocess/parser_raw.ml" +# 27228 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : (Longident.t) = Obj.magic _1 in @@ -21122,9 +27232,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Longident.t) = -# 3785 "src/ocaml/preprocess/parser_raw.mly" +# 3981 "src/ocaml/preprocess/parser_raw.mly" ( Ldot(_1,_3) ) -# 21128 "src/ocaml/preprocess/parser_raw.ml" +# 27238 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21143,17 +27253,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 845 "src/ocaml/preprocess/parser_raw.mly" +# 890 "src/ocaml/preprocess/parser_raw.mly" (string) -# 21149 "src/ocaml/preprocess/parser_raw.ml" +# 27259 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3784 "src/ocaml/preprocess/parser_raw.mly" +# 3980 "src/ocaml/preprocess/parser_raw.mly" ( Lident _1 ) -# 21157 "src/ocaml/preprocess/parser_raw.ml" +# 27267 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21184,9 +27294,9 @@ module Tables = struct }; } = _menhir_stack in let _3 : ( -# 845 "src/ocaml/preprocess/parser_raw.mly" +# 890 "src/ocaml/preprocess/parser_raw.mly" (string) -# 21190 "src/ocaml/preprocess/parser_raw.ml" +# 27300 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : (Longident.t) = Obj.magic _1 in @@ -21194,9 +27304,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Longident.t) = -# 3785 "src/ocaml/preprocess/parser_raw.mly" +# 3981 "src/ocaml/preprocess/parser_raw.mly" ( Ldot(_1,_3) ) -# 21200 "src/ocaml/preprocess/parser_raw.ml" +# 27310 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21219,14 +27329,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = let _1 = -# 3824 "src/ocaml/preprocess/parser_raw.mly" +# 4020 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 21225 "src/ocaml/preprocess/parser_raw.ml" +# 27335 "src/ocaml/preprocess/parser_raw.ml" in -# 3784 "src/ocaml/preprocess/parser_raw.mly" +# 3980 "src/ocaml/preprocess/parser_raw.mly" ( Lident _1 ) -# 21230 "src/ocaml/preprocess/parser_raw.ml" +# 27340 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21264,20 +27374,20 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Longident.t) = let _1 = let _1 = -# 3764 "src/ocaml/preprocess/parser_raw.mly" +# 3960 "src/ocaml/preprocess/parser_raw.mly" ( "::" ) -# 21270 "src/ocaml/preprocess/parser_raw.ml" +# 27380 "src/ocaml/preprocess/parser_raw.ml" in -# 3824 "src/ocaml/preprocess/parser_raw.mly" +# 4020 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 21275 "src/ocaml/preprocess/parser_raw.ml" +# 27385 "src/ocaml/preprocess/parser_raw.ml" in -# 3784 "src/ocaml/preprocess/parser_raw.mly" +# 3980 "src/ocaml/preprocess/parser_raw.mly" ( Lident _1 ) -# 21281 "src/ocaml/preprocess/parser_raw.ml" +# 27391 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21300,14 +27410,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = let _1 = -# 3824 "src/ocaml/preprocess/parser_raw.mly" +# 4020 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 21306 "src/ocaml/preprocess/parser_raw.ml" +# 27416 "src/ocaml/preprocess/parser_raw.ml" in -# 3784 "src/ocaml/preprocess/parser_raw.mly" +# 3980 "src/ocaml/preprocess/parser_raw.mly" ( Lident _1 ) -# 21311 "src/ocaml/preprocess/parser_raw.ml" +# 27421 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21346,15 +27456,15 @@ module Tables = struct let _v : (Longident.t) = let _3 = let _1 = _1_inlined1 in -# 3824 "src/ocaml/preprocess/parser_raw.mly" +# 4020 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 21352 "src/ocaml/preprocess/parser_raw.ml" +# 27462 "src/ocaml/preprocess/parser_raw.ml" in -# 3785 "src/ocaml/preprocess/parser_raw.mly" +# 3981 "src/ocaml/preprocess/parser_raw.mly" ( Ldot(_1,_3) ) -# 21358 "src/ocaml/preprocess/parser_raw.ml" +# 27468 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21407,20 +27517,20 @@ module Tables = struct let _v : (Longident.t) = let _3 = let (_2, _1) = (_2_inlined1, _1_inlined1) in let _1 = -# 3764 "src/ocaml/preprocess/parser_raw.mly" +# 3960 "src/ocaml/preprocess/parser_raw.mly" ( "::" ) -# 21413 "src/ocaml/preprocess/parser_raw.ml" +# 27523 "src/ocaml/preprocess/parser_raw.ml" in -# 3824 "src/ocaml/preprocess/parser_raw.mly" +# 4020 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 21418 "src/ocaml/preprocess/parser_raw.ml" +# 27528 "src/ocaml/preprocess/parser_raw.ml" in -# 3785 "src/ocaml/preprocess/parser_raw.mly" +# 3981 "src/ocaml/preprocess/parser_raw.mly" ( Ldot(_1,_3) ) -# 21424 "src/ocaml/preprocess/parser_raw.ml" +# 27534 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21459,15 +27569,15 @@ module Tables = struct let _v : (Longident.t) = let _3 = let _1 = _1_inlined1 in -# 3824 "src/ocaml/preprocess/parser_raw.mly" +# 4020 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 21465 "src/ocaml/preprocess/parser_raw.ml" +# 27575 "src/ocaml/preprocess/parser_raw.ml" in -# 3785 "src/ocaml/preprocess/parser_raw.mly" +# 3981 "src/ocaml/preprocess/parser_raw.mly" ( Ldot(_1,_3) ) -# 21471 "src/ocaml/preprocess/parser_raw.ml" +# 27581 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21490,9 +27600,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3784 "src/ocaml/preprocess/parser_raw.mly" +# 3980 "src/ocaml/preprocess/parser_raw.mly" ( Lident _1 ) -# 21496 "src/ocaml/preprocess/parser_raw.ml" +# 27606 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21529,9 +27639,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Longident.t) = -# 3785 "src/ocaml/preprocess/parser_raw.mly" +# 3981 "src/ocaml/preprocess/parser_raw.mly" ( Ldot(_1,_3) ) -# 21535 "src/ocaml/preprocess/parser_raw.ml" +# 27645 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21550,17 +27660,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 21556 "src/ocaml/preprocess/parser_raw.ml" +# 27666 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3784 "src/ocaml/preprocess/parser_raw.mly" +# 3980 "src/ocaml/preprocess/parser_raw.mly" ( Lident _1 ) -# 21564 "src/ocaml/preprocess/parser_raw.ml" +# 27674 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21591,9 +27701,9 @@ module Tables = struct }; } = _menhir_stack in let _3 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 21597 "src/ocaml/preprocess/parser_raw.ml" +# 27707 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : (Longident.t) = Obj.magic _1 in @@ -21601,9 +27711,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Longident.t) = -# 3785 "src/ocaml/preprocess/parser_raw.mly" +# 3981 "src/ocaml/preprocess/parser_raw.mly" ( Ldot(_1,_3) ) -# 21607 "src/ocaml/preprocess/parser_raw.ml" +# 27717 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21622,17 +27732,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 845 "src/ocaml/preprocess/parser_raw.mly" +# 890 "src/ocaml/preprocess/parser_raw.mly" (string) -# 21628 "src/ocaml/preprocess/parser_raw.ml" +# 27738 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3784 "src/ocaml/preprocess/parser_raw.mly" +# 3980 "src/ocaml/preprocess/parser_raw.mly" ( Lident _1 ) -# 21636 "src/ocaml/preprocess/parser_raw.ml" +# 27746 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21663,9 +27773,9 @@ module Tables = struct }; } = _menhir_stack in let _3 : ( -# 845 "src/ocaml/preprocess/parser_raw.mly" +# 890 "src/ocaml/preprocess/parser_raw.mly" (string) -# 21669 "src/ocaml/preprocess/parser_raw.ml" +# 27779 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : (Longident.t) = Obj.magic _1 in @@ -21673,9 +27783,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Longident.t) = -# 3785 "src/ocaml/preprocess/parser_raw.mly" +# 3981 "src/ocaml/preprocess/parser_raw.mly" ( Ldot(_1,_3) ) -# 21679 "src/ocaml/preprocess/parser_raw.ml" +# 27789 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21698,9 +27808,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3784 "src/ocaml/preprocess/parser_raw.mly" +# 3980 "src/ocaml/preprocess/parser_raw.mly" ( Lident _1 ) -# 21704 "src/ocaml/preprocess/parser_raw.ml" +# 27814 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21737,9 +27847,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Longident.t) = -# 3785 "src/ocaml/preprocess/parser_raw.mly" +# 3981 "src/ocaml/preprocess/parser_raw.mly" ( Ldot(_1,_3) ) -# 21743 "src/ocaml/preprocess/parser_raw.ml" +# 27853 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21762,9 +27872,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3800 "src/ocaml/preprocess/parser_raw.mly" +# 3996 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 21768 "src/ocaml/preprocess/parser_raw.ml" +# 27878 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21811,9 +27921,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3802 "src/ocaml/preprocess/parser_raw.mly" +# 3998 "src/ocaml/preprocess/parser_raw.mly" ( lapply ~loc:_sloc _1 _3 ) -# 21817 "src/ocaml/preprocess/parser_raw.ml" +# 27927 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21836,9 +27946,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3797 "src/ocaml/preprocess/parser_raw.mly" +# 3993 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 21842 "src/ocaml/preprocess/parser_raw.ml" +# 27952 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21868,9 +27978,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos_me_ in let _v : (Parsetree.module_expr) = -# 1578 "src/ocaml/preprocess/parser_raw.mly" +# 1639 "src/ocaml/preprocess/parser_raw.mly" ( me ) -# 21874 "src/ocaml/preprocess/parser_raw.ml" +# 27984 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21915,24 +28025,24 @@ module Tables = struct let _endpos = _endpos_me_ in let _v : (Parsetree.module_expr) = let _1 = let _1 = -# 1581 "src/ocaml/preprocess/parser_raw.mly" +# 1646 "src/ocaml/preprocess/parser_raw.mly" ( Pmod_constraint(me, mty) ) -# 21921 "src/ocaml/preprocess/parser_raw.ml" +# 28031 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos_me_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1033 "src/ocaml/preprocess/parser_raw.mly" +# 1070 "src/ocaml/preprocess/parser_raw.mly" ( mkmod ~loc:_sloc _1 ) -# 21930 "src/ocaml/preprocess/parser_raw.ml" +# 28040 "src/ocaml/preprocess/parser_raw.ml" in -# 1585 "src/ocaml/preprocess/parser_raw.mly" +# 1650 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 21936 "src/ocaml/preprocess/parser_raw.ml" +# 28046 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -21963,25 +28073,25 @@ module Tables = struct let _endpos = _endpos_body_ in let _v : (Parsetree.module_expr) = let _1 = let _1 = -# 1583 "src/ocaml/preprocess/parser_raw.mly" +# 1648 "src/ocaml/preprocess/parser_raw.mly" ( let (_, arg) = arg_and_pos in Pmod_functor(arg, body) ) -# 21970 "src/ocaml/preprocess/parser_raw.ml" +# 28080 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_body_, _startpos_arg_and_pos_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1033 "src/ocaml/preprocess/parser_raw.mly" +# 1070 "src/ocaml/preprocess/parser_raw.mly" ( mkmod ~loc:_sloc _1 ) -# 21979 "src/ocaml/preprocess/parser_raw.ml" +# 28089 "src/ocaml/preprocess/parser_raw.ml" in -# 1585 "src/ocaml/preprocess/parser_raw.mly" +# 1650 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 21985 "src/ocaml/preprocess/parser_raw.ml" +# 28095 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22011,9 +28121,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos_mty_ in let _v : (Parsetree.module_type) = -# 1828 "src/ocaml/preprocess/parser_raw.mly" +# 1899 "src/ocaml/preprocess/parser_raw.mly" ( mty ) -# 22017 "src/ocaml/preprocess/parser_raw.ml" +# 28127 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22044,25 +28154,25 @@ module Tables = struct let _endpos = _endpos_body_ in let _v : (Parsetree.module_type) = let _1 = let _1 = -# 1831 "src/ocaml/preprocess/parser_raw.mly" +# 1906 "src/ocaml/preprocess/parser_raw.mly" ( let (_, arg) = arg_and_pos in Pmty_functor(arg, body) ) -# 22051 "src/ocaml/preprocess/parser_raw.ml" +# 28161 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_body_, _startpos_arg_and_pos_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1035 "src/ocaml/preprocess/parser_raw.mly" +# 1072 "src/ocaml/preprocess/parser_raw.mly" ( mkmty ~loc:_sloc _1 ) -# 22060 "src/ocaml/preprocess/parser_raw.ml" +# 28170 "src/ocaml/preprocess/parser_raw.ml" in -# 1834 "src/ocaml/preprocess/parser_raw.mly" +# 1909 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 22066 "src/ocaml/preprocess/parser_raw.ml" +# 28176 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22108,18 +28218,18 @@ module Tables = struct let _v : (Parsetree.module_expr) = let attrs = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 22114 "src/ocaml/preprocess/parser_raw.ml" +# 28224 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1405 "src/ocaml/preprocess/parser_raw.mly" +# 1463 "src/ocaml/preprocess/parser_raw.mly" ( mkmod ~loc:_sloc ~attrs (Pmod_structure s) ) -# 22123 "src/ocaml/preprocess/parser_raw.ml" +# 28233 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22172,22 +28282,22 @@ module Tables = struct let _v : (Parsetree.module_expr) = let attrs = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 22178 "src/ocaml/preprocess/parser_raw.ml" +# 28288 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_me_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1411 "src/ocaml/preprocess/parser_raw.mly" +# 1473 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mod_attrs ~loc:_sloc attrs ( List.fold_left (fun acc (startpos, arg) -> mkmod ~loc:(startpos, _endpos) (Pmod_functor (arg, acc)) ) me args ) ) -# 22191 "src/ocaml/preprocess/parser_raw.ml" +# 28301 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22210,9 +28320,9 @@ module Tables = struct let _startpos = _startpos_me_ in let _endpos = _endpos_me_ in let _v : (Parsetree.module_expr) = -# 1417 "src/ocaml/preprocess/parser_raw.mly" +# 1479 "src/ocaml/preprocess/parser_raw.mly" ( me ) -# 22216 "src/ocaml/preprocess/parser_raw.ml" +# 28326 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22242,9 +28352,9 @@ module Tables = struct let _startpos = _startpos_me_ in let _endpos = _endpos_attr_ in let _v : (Parsetree.module_expr) = -# 1419 "src/ocaml/preprocess/parser_raw.mly" +# 1481 "src/ocaml/preprocess/parser_raw.mly" ( Mod.attr me attr ) -# 22248 "src/ocaml/preprocess/parser_raw.ml" +# 28358 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22273,30 +28383,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 22279 "src/ocaml/preprocess/parser_raw.ml" +# 28389 "src/ocaml/preprocess/parser_raw.ml" in -# 1423 "src/ocaml/preprocess/parser_raw.mly" +# 1485 "src/ocaml/preprocess/parser_raw.mly" ( Pmod_ident x ) -# 22285 "src/ocaml/preprocess/parser_raw.ml" +# 28395 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1033 "src/ocaml/preprocess/parser_raw.mly" +# 1070 "src/ocaml/preprocess/parser_raw.mly" ( mkmod ~loc:_sloc _1 ) -# 22294 "src/ocaml/preprocess/parser_raw.ml" +# 28404 "src/ocaml/preprocess/parser_raw.ml" in -# 1439 "src/ocaml/preprocess/parser_raw.mly" +# 1500 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 22300 "src/ocaml/preprocess/parser_raw.ml" +# 28410 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22327,24 +28437,24 @@ module Tables = struct let _endpos = _endpos_me2_ in let _v : (Parsetree.module_expr) = let _1 = let _1 = -# 1426 "src/ocaml/preprocess/parser_raw.mly" +# 1488 "src/ocaml/preprocess/parser_raw.mly" ( Pmod_apply(me1, me2) ) -# 22333 "src/ocaml/preprocess/parser_raw.ml" +# 28443 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_me2_, _startpos_me1_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1033 "src/ocaml/preprocess/parser_raw.mly" +# 1070 "src/ocaml/preprocess/parser_raw.mly" ( mkmod ~loc:_sloc _1 ) -# 22342 "src/ocaml/preprocess/parser_raw.ml" +# 28452 "src/ocaml/preprocess/parser_raw.ml" in -# 1439 "src/ocaml/preprocess/parser_raw.mly" +# 1500 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 22348 "src/ocaml/preprocess/parser_raw.ml" +# 28458 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22367,45 +28477,39 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = me1; - MenhirLib.EngineTypes.startp = _startpos_me1_; - MenhirLib.EngineTypes.endp = _endpos_me1_; + MenhirLib.EngineTypes.semv = me; + MenhirLib.EngineTypes.startp = _startpos_me_; + MenhirLib.EngineTypes.endp = _endpos_me_; MenhirLib.EngineTypes.next = _menhir_stack; }; }; } = _menhir_stack in let _3 : unit = Obj.magic _3 in let _2 : unit = Obj.magic _2 in - let me1 : (Parsetree.module_expr) = Obj.magic me1 in + let me : (Parsetree.module_expr) = Obj.magic me in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_me1_ in + let _startpos = _startpos_me_ in let _endpos = _endpos__3_ in let _v : (Parsetree.module_expr) = let _1 = - let _1 = - let _endpos = _endpos__3_ in - let _symbolstartpos = _startpos_me1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1429 "src/ocaml/preprocess/parser_raw.mly" - ( (* TODO review mkmod location *) - Pmod_apply(me1, mkmod ~loc:_sloc (Pmod_structure [])) ) -# 22393 "src/ocaml/preprocess/parser_raw.ml" - - in - let (_endpos__1_, _startpos__1_) = (_endpos__3_, _startpos_me1_) in + let _1 = +# 1491 "src/ocaml/preprocess/parser_raw.mly" + ( Pmod_apply_unit me ) +# 28498 "src/ocaml/preprocess/parser_raw.ml" + in + let (_endpos__1_, _startpos__1_) = (_endpos__3_, _startpos_me_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1033 "src/ocaml/preprocess/parser_raw.mly" +# 1070 "src/ocaml/preprocess/parser_raw.mly" ( mkmod ~loc:_sloc _1 ) -# 22403 "src/ocaml/preprocess/parser_raw.ml" +# 28507 "src/ocaml/preprocess/parser_raw.ml" in -# 1439 "src/ocaml/preprocess/parser_raw.mly" +# 1500 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 22409 "src/ocaml/preprocess/parser_raw.ml" +# 28513 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22429,24 +28533,24 @@ module Tables = struct let _endpos = _endpos_ex_ in let _v : (Parsetree.module_expr) = let _1 = let _1 = -# 1433 "src/ocaml/preprocess/parser_raw.mly" +# 1494 "src/ocaml/preprocess/parser_raw.mly" ( Pmod_extension ex ) -# 22435 "src/ocaml/preprocess/parser_raw.ml" +# 28539 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_ex_, _startpos_ex_) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1033 "src/ocaml/preprocess/parser_raw.mly" +# 1070 "src/ocaml/preprocess/parser_raw.mly" ( mkmod ~loc:_sloc _1 ) -# 22444 "src/ocaml/preprocess/parser_raw.ml" +# 28548 "src/ocaml/preprocess/parser_raw.ml" in -# 1439 "src/ocaml/preprocess/parser_raw.mly" +# 1500 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 22450 "src/ocaml/preprocess/parser_raw.ml" +# 28554 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22474,25 +28578,25 @@ module Tables = struct let _startpos = _startpos__1_ in let _loc = (_startpos, _endpos) in -# 1436 "src/ocaml/preprocess/parser_raw.mly" +# 1497 "src/ocaml/preprocess/parser_raw.mly" ( let id = mkrhs Ast_helper.hole_txt _loc in Pmod_extension (id, PStr []) ) -# 22481 "src/ocaml/preprocess/parser_raw.ml" +# 28585 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1033 "src/ocaml/preprocess/parser_raw.mly" +# 1070 "src/ocaml/preprocess/parser_raw.mly" ( mkmod ~loc:_sloc _1 ) -# 22490 "src/ocaml/preprocess/parser_raw.ml" +# 28594 "src/ocaml/preprocess/parser_raw.ml" in -# 1439 "src/ocaml/preprocess/parser_raw.mly" +# 1500 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 22496 "src/ocaml/preprocess/parser_raw.ml" +# 28600 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22511,17 +28615,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let x : ( -# 845 "src/ocaml/preprocess/parser_raw.mly" +# 890 "src/ocaml/preprocess/parser_raw.mly" (string) -# 22517 "src/ocaml/preprocess/parser_raw.ml" +# 28621 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic x in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (string option) = -# 1388 "src/ocaml/preprocess/parser_raw.mly" +# 1446 "src/ocaml/preprocess/parser_raw.mly" ( Some x ) -# 22525 "src/ocaml/preprocess/parser_raw.ml" +# 28629 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22544,9 +28648,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string option) = -# 1391 "src/ocaml/preprocess/parser_raw.mly" +# 1449 "src/ocaml/preprocess/parser_raw.mly" ( None ) -# 22550 "src/ocaml/preprocess/parser_raw.ml" +# 28654 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22604,9 +28708,9 @@ module Tables = struct let _1_inlined3 : (Longident.t) = Obj.magic _1_inlined3 in let _5 : unit = Obj.magic _5 in let _1_inlined2 : ( -# 845 "src/ocaml/preprocess/parser_raw.mly" +# 890 "src/ocaml/preprocess/parser_raw.mly" (string) -# 22610 "src/ocaml/preprocess/parser_raw.ml" +# 28714 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in let ext : (string Location.loc option) = Obj.magic ext in @@ -22617,9 +28721,9 @@ module Tables = struct let _v : (Parsetree.module_substitution * string Location.loc option) = let attrs2 = let _1 = _1_inlined4 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 22623 "src/ocaml/preprocess/parser_raw.ml" +# 28727 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined4_ in @@ -22629,9 +28733,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 22635 "src/ocaml/preprocess/parser_raw.ml" +# 28739 "src/ocaml/preprocess/parser_raw.ml" in let uid = @@ -22640,31 +28744,31 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 22646 "src/ocaml/preprocess/parser_raw.ml" +# 28750 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 22654 "src/ocaml/preprocess/parser_raw.ml" +# 28758 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1864 "src/ocaml/preprocess/parser_raw.mly" +# 1939 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in let docs = symbol_docs _sloc in Ms.mk uid body ~attrs ~loc ~docs, ext ) -# 22668 "src/ocaml/preprocess/parser_raw.ml" +# 28772 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22710,18 +28814,18 @@ module Tables = struct let _v : (Parsetree.module_type) = let attrs = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 22716 "src/ocaml/preprocess/parser_raw.ml" +# 28820 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1710 "src/ocaml/preprocess/parser_raw.mly" +# 1775 "src/ocaml/preprocess/parser_raw.mly" ( mkmty ~loc:_sloc ~attrs (Pmty_signature s) ) -# 22725 "src/ocaml/preprocess/parser_raw.ml" +# 28829 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22774,22 +28878,22 @@ module Tables = struct let _v : (Parsetree.module_type) = let attrs = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 22780 "src/ocaml/preprocess/parser_raw.ml" +# 28884 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_mty_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1718 "src/ocaml/preprocess/parser_raw.mly" +# 1787 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mty_attrs ~loc:_sloc attrs ( List.fold_left (fun acc (startpos, arg) -> mkmty ~loc:(startpos, _endpos) (Pmty_functor (arg, acc)) ) mty args ) ) -# 22793 "src/ocaml/preprocess/parser_raw.ml" +# 28897 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22842,18 +28946,18 @@ module Tables = struct let _v : (Parsetree.module_type) = let _4 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 22848 "src/ocaml/preprocess/parser_raw.ml" +# 28952 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1724 "src/ocaml/preprocess/parser_raw.mly" +# 1793 "src/ocaml/preprocess/parser_raw.mly" ( mkmty ~loc:_sloc ~attrs:_4 (Pmty_typeof _5) ) -# 22857 "src/ocaml/preprocess/parser_raw.ml" +# 28961 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22890,9 +28994,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.module_type) = -# 1726 "src/ocaml/preprocess/parser_raw.mly" +# 1795 "src/ocaml/preprocess/parser_raw.mly" ( _2 ) -# 22896 "src/ocaml/preprocess/parser_raw.ml" +# 29000 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22922,9 +29026,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.module_type) = -# 1732 "src/ocaml/preprocess/parser_raw.mly" +# 1801 "src/ocaml/preprocess/parser_raw.mly" ( Mty.attr _1 _2 ) -# 22928 "src/ocaml/preprocess/parser_raw.ml" +# 29032 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -22953,30 +29057,92 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 22959 "src/ocaml/preprocess/parser_raw.ml" +# 29063 "src/ocaml/preprocess/parser_raw.ml" in -# 1735 "src/ocaml/preprocess/parser_raw.mly" +# 1804 "src/ocaml/preprocess/parser_raw.mly" ( Pmty_ident _1 ) -# 22965 "src/ocaml/preprocess/parser_raw.ml" +# 29069 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1035 "src/ocaml/preprocess/parser_raw.mly" +# 1072 "src/ocaml/preprocess/parser_raw.mly" ( mkmty ~loc:_sloc _1 ) -# 22974 "src/ocaml/preprocess/parser_raw.ml" +# 29078 "src/ocaml/preprocess/parser_raw.ml" in -# 1746 "src/ocaml/preprocess/parser_raw.mly" +# 1817 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 22980 "src/ocaml/preprocess/parser_raw.ml" +# 29084 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + } = _menhir_stack in + let _4 : (Parsetree.module_type) = Obj.magic _4 in + let _3 : unit = Obj.magic _3 in + let _2 : unit = Obj.magic _2 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__4_ in + let _v : (Parsetree.module_type) = let _1 = + let _1 = +# 1806 "src/ocaml/preprocess/parser_raw.mly" + ( Pmty_functor(Unit, _4) ) +# 29131 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos__1_ = _endpos__4_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1072 "src/ocaml/preprocess/parser_raw.mly" + ( mkmty ~loc:_sloc _1 ) +# 29140 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 1817 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 29146 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23014,24 +29180,24 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Parsetree.module_type) = let _1 = let _1 = -# 1738 "src/ocaml/preprocess/parser_raw.mly" +# 1809 "src/ocaml/preprocess/parser_raw.mly" ( Pmty_functor(Named (mknoloc None, _1), _3) ) -# 23020 "src/ocaml/preprocess/parser_raw.ml" +# 29186 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1035 "src/ocaml/preprocess/parser_raw.mly" +# 1072 "src/ocaml/preprocess/parser_raw.mly" ( mkmty ~loc:_sloc _1 ) -# 23029 "src/ocaml/preprocess/parser_raw.ml" +# 29195 "src/ocaml/preprocess/parser_raw.ml" in -# 1746 "src/ocaml/preprocess/parser_raw.mly" +# 1817 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 23035 "src/ocaml/preprocess/parser_raw.ml" +# 29201 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23073,18 +29239,18 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 23077 "src/ocaml/preprocess/parser_raw.ml" +# 29243 "src/ocaml/preprocess/parser_raw.ml" in -# 1124 "src/ocaml/preprocess/parser_raw.mly" +# 1182 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 23082 "src/ocaml/preprocess/parser_raw.ml" +# 29248 "src/ocaml/preprocess/parser_raw.ml" in -# 1740 "src/ocaml/preprocess/parser_raw.mly" +# 1811 "src/ocaml/preprocess/parser_raw.mly" ( Pmty_with(_1, _3) ) -# 23088 "src/ocaml/preprocess/parser_raw.ml" +# 29254 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos_xs_ in @@ -23092,15 +29258,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1035 "src/ocaml/preprocess/parser_raw.mly" +# 1072 "src/ocaml/preprocess/parser_raw.mly" ( mkmty ~loc:_sloc _1 ) -# 23098 "src/ocaml/preprocess/parser_raw.ml" +# 29264 "src/ocaml/preprocess/parser_raw.ml" in -# 1746 "src/ocaml/preprocess/parser_raw.mly" +# 1817 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 23104 "src/ocaml/preprocess/parser_raw.ml" +# 29270 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23124,23 +29290,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.module_type) = let _1 = let _1 = -# 1744 "src/ocaml/preprocess/parser_raw.mly" +# 1815 "src/ocaml/preprocess/parser_raw.mly" ( Pmty_extension _1 ) -# 23130 "src/ocaml/preprocess/parser_raw.ml" +# 29296 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1035 "src/ocaml/preprocess/parser_raw.mly" +# 1072 "src/ocaml/preprocess/parser_raw.mly" ( mkmty ~loc:_sloc _1 ) -# 23138 "src/ocaml/preprocess/parser_raw.ml" +# 29304 "src/ocaml/preprocess/parser_raw.ml" in -# 1746 "src/ocaml/preprocess/parser_raw.mly" +# 1817 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 23144 "src/ocaml/preprocess/parser_raw.ml" +# 29310 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23207,9 +29373,9 @@ module Tables = struct let _v : (Parsetree.module_type_declaration * string Location.loc option) = let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 23213 "src/ocaml/preprocess/parser_raw.ml" +# 29379 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -23219,31 +29385,31 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 23225 "src/ocaml/preprocess/parser_raw.ml" +# 29391 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 23233 "src/ocaml/preprocess/parser_raw.ml" +# 29399 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1656 "src/ocaml/preprocess/parser_raw.mly" +# 1721 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in let docs = symbol_docs _sloc in Mtd.mk id ?typ ~attrs ~loc ~docs, ext ) -# 23247 "src/ocaml/preprocess/parser_raw.ml" +# 29413 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23317,9 +29483,9 @@ module Tables = struct let _v : (Parsetree.module_type_declaration * string Location.loc option) = let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 23323 "src/ocaml/preprocess/parser_raw.ml" +# 29489 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -23329,31 +29495,31 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 23335 "src/ocaml/preprocess/parser_raw.ml" +# 29501 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 23343 "src/ocaml/preprocess/parser_raw.ml" +# 29509 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1922 "src/ocaml/preprocess/parser_raw.mly" +# 1997 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in let docs = symbol_docs _sloc in Mtd.mk id ~typ ~attrs ~loc ~docs, ext ) -# 23357 "src/ocaml/preprocess/parser_raw.ml" +# 29523 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23376,9 +29542,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3809 "src/ocaml/preprocess/parser_raw.mly" +# 4005 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 23382 "src/ocaml/preprocess/parser_raw.ml" +# 29548 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23394,9 +29560,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Asttypes.mutable_flag) = -# 3890 "src/ocaml/preprocess/parser_raw.mly" +# 4086 "src/ocaml/preprocess/parser_raw.mly" ( Immutable ) -# 23400 "src/ocaml/preprocess/parser_raw.ml" +# 29566 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23419,9 +29585,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.mutable_flag) = -# 3891 "src/ocaml/preprocess/parser_raw.mly" +# 4087 "src/ocaml/preprocess/parser_raw.mly" ( Mutable ) -# 23425 "src/ocaml/preprocess/parser_raw.ml" +# 29591 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23437,9 +29603,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) = -# 3899 "src/ocaml/preprocess/parser_raw.mly" +# 4095 "src/ocaml/preprocess/parser_raw.mly" ( Immutable, Concrete ) -# 23443 "src/ocaml/preprocess/parser_raw.ml" +# 29609 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23462,9 +29628,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) = -# 3901 "src/ocaml/preprocess/parser_raw.mly" +# 4097 "src/ocaml/preprocess/parser_raw.mly" ( Mutable, Concrete ) -# 23468 "src/ocaml/preprocess/parser_raw.ml" +# 29634 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23487,9 +29653,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) = -# 3903 "src/ocaml/preprocess/parser_raw.mly" +# 4099 "src/ocaml/preprocess/parser_raw.mly" ( Immutable, Virtual ) -# 23493 "src/ocaml/preprocess/parser_raw.ml" +# 29659 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23519,9 +29685,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) = -# 3906 "src/ocaml/preprocess/parser_raw.mly" +# 4102 "src/ocaml/preprocess/parser_raw.mly" ( Mutable, Virtual ) -# 23525 "src/ocaml/preprocess/parser_raw.ml" +# 29691 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23551,9 +29717,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) = -# 3906 "src/ocaml/preprocess/parser_raw.mly" +# 4102 "src/ocaml/preprocess/parser_raw.mly" ( Mutable, Virtual ) -# 23557 "src/ocaml/preprocess/parser_raw.ml" +# 29723 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23583,9 +29749,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (string) = -# 3861 "src/ocaml/preprocess/parser_raw.mly" +# 4057 "src/ocaml/preprocess/parser_raw.mly" ( _2 ) -# 23589 "src/ocaml/preprocess/parser_raw.ml" +# 29755 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23604,9 +29770,9 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 23610 "src/ocaml/preprocess/parser_raw.ml" +# 29776 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -23616,15 +29782,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 23622 "src/ocaml/preprocess/parser_raw.ml" +# 29788 "src/ocaml/preprocess/parser_raw.ml" in # 221 "" ( [ x ] ) -# 23628 "src/ocaml/preprocess/parser_raw.ml" +# 29794 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23650,9 +29816,9 @@ module Tables = struct } = _menhir_stack in let xs : (string Location.loc list) = Obj.magic xs in let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 23656 "src/ocaml/preprocess/parser_raw.ml" +# 29822 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -23662,15 +29828,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 23668 "src/ocaml/preprocess/parser_raw.ml" +# 29834 "src/ocaml/preprocess/parser_raw.ml" in # 223 "" ( x :: xs ) -# 23674 "src/ocaml/preprocess/parser_raw.ml" +# 29840 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23689,22 +29855,22 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let s : ( -# 831 "src/ocaml/preprocess/parser_raw.mly" +# 876 "src/ocaml/preprocess/parser_raw.mly" (string * Location.t * string option) -# 23695 "src/ocaml/preprocess/parser_raw.ml" +# 29861 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic s in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_s_ in let _endpos = _endpos_s_ in let _v : (string list) = let x = -# 3857 "src/ocaml/preprocess/parser_raw.mly" +# 4053 "src/ocaml/preprocess/parser_raw.mly" ( let body, _, _ = s in body ) -# 23703 "src/ocaml/preprocess/parser_raw.ml" +# 29869 "src/ocaml/preprocess/parser_raw.ml" in # 221 "" ( [ x ] ) -# 23708 "src/ocaml/preprocess/parser_raw.ml" +# 29874 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23730,22 +29896,22 @@ module Tables = struct } = _menhir_stack in let xs : (string list) = Obj.magic xs in let s : ( -# 831 "src/ocaml/preprocess/parser_raw.mly" +# 876 "src/ocaml/preprocess/parser_raw.mly" (string * Location.t * string option) -# 23736 "src/ocaml/preprocess/parser_raw.ml" +# 29902 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic s in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_s_ in let _endpos = _endpos_xs_ in let _v : (string list) = let x = -# 3857 "src/ocaml/preprocess/parser_raw.mly" +# 4053 "src/ocaml/preprocess/parser_raw.mly" ( let body, _, _ = s in body ) -# 23744 "src/ocaml/preprocess/parser_raw.ml" +# 29910 "src/ocaml/preprocess/parser_raw.ml" in # 223 "" ( x :: xs ) -# 23749 "src/ocaml/preprocess/parser_raw.ml" +# 29915 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23768,14 +29934,14 @@ module Tables = struct let _startpos = _startpos_ty_ in let _endpos = _endpos_ty_ in let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = -# 3886 "src/ocaml/preprocess/parser_raw.mly" +# 4082 "src/ocaml/preprocess/parser_raw.mly" ( Public ) -# 23774 "src/ocaml/preprocess/parser_raw.ml" +# 29940 "src/ocaml/preprocess/parser_raw.ml" in -# 3166 "src/ocaml/preprocess/parser_raw.mly" +# 3306 "src/ocaml/preprocess/parser_raw.mly" ( (Ptype_abstract, priv, Some ty) ) -# 23779 "src/ocaml/preprocess/parser_raw.ml" +# 29945 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23805,14 +29971,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos_ty_ in let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = -# 3887 "src/ocaml/preprocess/parser_raw.mly" +# 4083 "src/ocaml/preprocess/parser_raw.mly" ( Private ) -# 23811 "src/ocaml/preprocess/parser_raw.ml" +# 29977 "src/ocaml/preprocess/parser_raw.ml" in -# 3166 "src/ocaml/preprocess/parser_raw.mly" +# 3306 "src/ocaml/preprocess/parser_raw.mly" ( (Ptype_abstract, priv, Some ty) ) -# 23816 "src/ocaml/preprocess/parser_raw.ml" +# 29982 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23835,26 +30001,26 @@ module Tables = struct let _startpos = _startpos_cs_ in let _endpos = _endpos_cs_ in let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = -# 3886 "src/ocaml/preprocess/parser_raw.mly" +# 4082 "src/ocaml/preprocess/parser_raw.mly" ( Public ) -# 23841 "src/ocaml/preprocess/parser_raw.ml" +# 30007 "src/ocaml/preprocess/parser_raw.ml" in let oty = let _1 = # 124 "" ( None ) -# 23847 "src/ocaml/preprocess/parser_raw.ml" +# 30013 "src/ocaml/preprocess/parser_raw.ml" in -# 3182 "src/ocaml/preprocess/parser_raw.mly" +# 3322 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 23852 "src/ocaml/preprocess/parser_raw.ml" +# 30018 "src/ocaml/preprocess/parser_raw.ml" in -# 3170 "src/ocaml/preprocess/parser_raw.mly" +# 3310 "src/ocaml/preprocess/parser_raw.mly" ( (Ptype_variant cs, priv, oty) ) -# 23858 "src/ocaml/preprocess/parser_raw.ml" +# 30024 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23884,26 +30050,26 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos_cs_ in let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = -# 3887 "src/ocaml/preprocess/parser_raw.mly" +# 4083 "src/ocaml/preprocess/parser_raw.mly" ( Private ) -# 23890 "src/ocaml/preprocess/parser_raw.ml" +# 30056 "src/ocaml/preprocess/parser_raw.ml" in let oty = let _1 = # 124 "" ( None ) -# 23896 "src/ocaml/preprocess/parser_raw.ml" +# 30062 "src/ocaml/preprocess/parser_raw.ml" in -# 3182 "src/ocaml/preprocess/parser_raw.mly" +# 3322 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 23901 "src/ocaml/preprocess/parser_raw.ml" +# 30067 "src/ocaml/preprocess/parser_raw.ml" in -# 3170 "src/ocaml/preprocess/parser_raw.mly" +# 3310 "src/ocaml/preprocess/parser_raw.mly" ( (Ptype_variant cs, priv, oty) ) -# 23907 "src/ocaml/preprocess/parser_raw.ml" +# 30073 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -23940,33 +30106,33 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_cs_ in let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = -# 3886 "src/ocaml/preprocess/parser_raw.mly" +# 4082 "src/ocaml/preprocess/parser_raw.mly" ( Public ) -# 23946 "src/ocaml/preprocess/parser_raw.ml" +# 30112 "src/ocaml/preprocess/parser_raw.ml" in let oty = let _1 = let x = # 191 "" ( x ) -# 23953 "src/ocaml/preprocess/parser_raw.ml" +# 30119 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 23958 "src/ocaml/preprocess/parser_raw.ml" +# 30124 "src/ocaml/preprocess/parser_raw.ml" in -# 3182 "src/ocaml/preprocess/parser_raw.mly" +# 3322 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 23964 "src/ocaml/preprocess/parser_raw.ml" +# 30130 "src/ocaml/preprocess/parser_raw.ml" in -# 3170 "src/ocaml/preprocess/parser_raw.mly" +# 3310 "src/ocaml/preprocess/parser_raw.mly" ( (Ptype_variant cs, priv, oty) ) -# 23970 "src/ocaml/preprocess/parser_raw.ml" +# 30136 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24010,33 +30176,33 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_cs_ in let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = -# 3887 "src/ocaml/preprocess/parser_raw.mly" +# 4083 "src/ocaml/preprocess/parser_raw.mly" ( Private ) -# 24016 "src/ocaml/preprocess/parser_raw.ml" +# 30182 "src/ocaml/preprocess/parser_raw.ml" in let oty = let _1 = let x = # 191 "" ( x ) -# 24023 "src/ocaml/preprocess/parser_raw.ml" +# 30189 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 24028 "src/ocaml/preprocess/parser_raw.ml" +# 30194 "src/ocaml/preprocess/parser_raw.ml" in -# 3182 "src/ocaml/preprocess/parser_raw.mly" +# 3322 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24034 "src/ocaml/preprocess/parser_raw.ml" +# 30200 "src/ocaml/preprocess/parser_raw.ml" in -# 3170 "src/ocaml/preprocess/parser_raw.mly" +# 3310 "src/ocaml/preprocess/parser_raw.mly" ( (Ptype_variant cs, priv, oty) ) -# 24040 "src/ocaml/preprocess/parser_raw.ml" +# 30206 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24059,26 +30225,26 @@ module Tables = struct let _startpos = _startpos__3_ in let _endpos = _endpos__3_ in let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = -# 3886 "src/ocaml/preprocess/parser_raw.mly" +# 4082 "src/ocaml/preprocess/parser_raw.mly" ( Public ) -# 24065 "src/ocaml/preprocess/parser_raw.ml" +# 30231 "src/ocaml/preprocess/parser_raw.ml" in let oty = let _1 = # 124 "" ( None ) -# 24071 "src/ocaml/preprocess/parser_raw.ml" +# 30237 "src/ocaml/preprocess/parser_raw.ml" in -# 3182 "src/ocaml/preprocess/parser_raw.mly" +# 3322 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24076 "src/ocaml/preprocess/parser_raw.ml" +# 30242 "src/ocaml/preprocess/parser_raw.ml" in -# 3174 "src/ocaml/preprocess/parser_raw.mly" +# 3314 "src/ocaml/preprocess/parser_raw.mly" ( (Ptype_open, priv, oty) ) -# 24082 "src/ocaml/preprocess/parser_raw.ml" +# 30248 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24108,26 +30274,26 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = -# 3887 "src/ocaml/preprocess/parser_raw.mly" +# 4083 "src/ocaml/preprocess/parser_raw.mly" ( Private ) -# 24114 "src/ocaml/preprocess/parser_raw.ml" +# 30280 "src/ocaml/preprocess/parser_raw.ml" in let oty = let _1 = # 124 "" ( None ) -# 24120 "src/ocaml/preprocess/parser_raw.ml" +# 30286 "src/ocaml/preprocess/parser_raw.ml" in -# 3182 "src/ocaml/preprocess/parser_raw.mly" +# 3322 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24125 "src/ocaml/preprocess/parser_raw.ml" +# 30291 "src/ocaml/preprocess/parser_raw.ml" in -# 3174 "src/ocaml/preprocess/parser_raw.mly" +# 3314 "src/ocaml/preprocess/parser_raw.mly" ( (Ptype_open, priv, oty) ) -# 24131 "src/ocaml/preprocess/parser_raw.ml" +# 30297 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24164,33 +30330,33 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos__3_ in let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = -# 3886 "src/ocaml/preprocess/parser_raw.mly" +# 4082 "src/ocaml/preprocess/parser_raw.mly" ( Public ) -# 24170 "src/ocaml/preprocess/parser_raw.ml" +# 30336 "src/ocaml/preprocess/parser_raw.ml" in let oty = let _1 = let x = # 191 "" ( x ) -# 24177 "src/ocaml/preprocess/parser_raw.ml" +# 30343 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 24182 "src/ocaml/preprocess/parser_raw.ml" +# 30348 "src/ocaml/preprocess/parser_raw.ml" in -# 3182 "src/ocaml/preprocess/parser_raw.mly" +# 3322 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24188 "src/ocaml/preprocess/parser_raw.ml" +# 30354 "src/ocaml/preprocess/parser_raw.ml" in -# 3174 "src/ocaml/preprocess/parser_raw.mly" +# 3314 "src/ocaml/preprocess/parser_raw.mly" ( (Ptype_open, priv, oty) ) -# 24194 "src/ocaml/preprocess/parser_raw.ml" +# 30360 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24234,33 +30400,33 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos__3_ in let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = -# 3887 "src/ocaml/preprocess/parser_raw.mly" +# 4083 "src/ocaml/preprocess/parser_raw.mly" ( Private ) -# 24240 "src/ocaml/preprocess/parser_raw.ml" +# 30406 "src/ocaml/preprocess/parser_raw.ml" in let oty = let _1 = let x = # 191 "" ( x ) -# 24247 "src/ocaml/preprocess/parser_raw.ml" +# 30413 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 24252 "src/ocaml/preprocess/parser_raw.ml" +# 30418 "src/ocaml/preprocess/parser_raw.ml" in -# 3182 "src/ocaml/preprocess/parser_raw.mly" +# 3322 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24258 "src/ocaml/preprocess/parser_raw.ml" +# 30424 "src/ocaml/preprocess/parser_raw.ml" in -# 3174 "src/ocaml/preprocess/parser_raw.mly" +# 3314 "src/ocaml/preprocess/parser_raw.mly" ( (Ptype_open, priv, oty) ) -# 24264 "src/ocaml/preprocess/parser_raw.ml" +# 30430 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24297,26 +30463,26 @@ module Tables = struct let _startpos = _startpos__3_ in let _endpos = _endpos__5_ in let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = -# 3886 "src/ocaml/preprocess/parser_raw.mly" +# 4082 "src/ocaml/preprocess/parser_raw.mly" ( Public ) -# 24303 "src/ocaml/preprocess/parser_raw.ml" +# 30469 "src/ocaml/preprocess/parser_raw.ml" in let oty = let _1 = # 124 "" ( None ) -# 24309 "src/ocaml/preprocess/parser_raw.ml" +# 30475 "src/ocaml/preprocess/parser_raw.ml" in -# 3182 "src/ocaml/preprocess/parser_raw.mly" +# 3322 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24314 "src/ocaml/preprocess/parser_raw.ml" +# 30480 "src/ocaml/preprocess/parser_raw.ml" in -# 3178 "src/ocaml/preprocess/parser_raw.mly" +# 3318 "src/ocaml/preprocess/parser_raw.mly" ( (Ptype_record ls, priv, oty) ) -# 24320 "src/ocaml/preprocess/parser_raw.ml" +# 30486 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24360,26 +30526,26 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = -# 3887 "src/ocaml/preprocess/parser_raw.mly" +# 4083 "src/ocaml/preprocess/parser_raw.mly" ( Private ) -# 24366 "src/ocaml/preprocess/parser_raw.ml" +# 30532 "src/ocaml/preprocess/parser_raw.ml" in let oty = let _1 = # 124 "" ( None ) -# 24372 "src/ocaml/preprocess/parser_raw.ml" +# 30538 "src/ocaml/preprocess/parser_raw.ml" in -# 3182 "src/ocaml/preprocess/parser_raw.mly" +# 3322 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24377 "src/ocaml/preprocess/parser_raw.ml" +# 30543 "src/ocaml/preprocess/parser_raw.ml" in -# 3178 "src/ocaml/preprocess/parser_raw.mly" +# 3318 "src/ocaml/preprocess/parser_raw.mly" ( (Ptype_record ls, priv, oty) ) -# 24383 "src/ocaml/preprocess/parser_raw.ml" +# 30549 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24430,33 +30596,33 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos__5_ in let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = -# 3886 "src/ocaml/preprocess/parser_raw.mly" +# 4082 "src/ocaml/preprocess/parser_raw.mly" ( Public ) -# 24436 "src/ocaml/preprocess/parser_raw.ml" +# 30602 "src/ocaml/preprocess/parser_raw.ml" in let oty = let _1 = let x = # 191 "" ( x ) -# 24443 "src/ocaml/preprocess/parser_raw.ml" +# 30609 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 24448 "src/ocaml/preprocess/parser_raw.ml" +# 30614 "src/ocaml/preprocess/parser_raw.ml" in -# 3182 "src/ocaml/preprocess/parser_raw.mly" +# 3322 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24454 "src/ocaml/preprocess/parser_raw.ml" +# 30620 "src/ocaml/preprocess/parser_raw.ml" in -# 3178 "src/ocaml/preprocess/parser_raw.mly" +# 3318 "src/ocaml/preprocess/parser_raw.mly" ( (Ptype_record ls, priv, oty) ) -# 24460 "src/ocaml/preprocess/parser_raw.ml" +# 30626 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24514,33 +30680,136 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos__5_ in let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = -# 3887 "src/ocaml/preprocess/parser_raw.mly" +# 4083 "src/ocaml/preprocess/parser_raw.mly" ( Private ) -# 24520 "src/ocaml/preprocess/parser_raw.ml" +# 30686 "src/ocaml/preprocess/parser_raw.ml" in let oty = let _1 = let x = # 191 "" ( x ) -# 24527 "src/ocaml/preprocess/parser_raw.ml" +# 30693 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 24532 "src/ocaml/preprocess/parser_raw.ml" +# 30698 "src/ocaml/preprocess/parser_raw.ml" in -# 3182 "src/ocaml/preprocess/parser_raw.mly" +# 3322 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24538 "src/ocaml/preprocess/parser_raw.ml" +# 30704 "src/ocaml/preprocess/parser_raw.ml" in -# 3178 "src/ocaml/preprocess/parser_raw.mly" +# 3318 "src/ocaml/preprocess/parser_raw.mly" ( (Ptype_record ls, priv, oty) ) -# 24544 "src/ocaml/preprocess/parser_raw.ml" +# 30710 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = meth_list; + MenhirLib.EngineTypes.startp = _startpos_meth_list_; + MenhirLib.EngineTypes.endp = _endpos_meth_list_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _3 : unit = Obj.magic _3 in + let meth_list : (Parsetree.object_field list * Asttypes.closed_flag) = Obj.magic meth_list in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__3_ in + let _v : (Parsetree.core_type) = let _1 = + let _1 = +# 3742 "src/ocaml/preprocess/parser_raw.mly" + ( let (f, c) = meth_list in Ptyp_object (f, c) ) +# 30750 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos__1_ = _endpos__3_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1064 "src/ocaml/preprocess/parser_raw.mly" + ( mktyp ~loc:_sloc _1 ) +# 30759 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3746 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 30765 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + } = _menhir_stack in + let _2 : unit = Obj.magic _2 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__2_ in + let _v : (Parsetree.core_type) = let _1 = + let _1 = +# 3744 "src/ocaml/preprocess/parser_raw.mly" + ( Ptyp_object ([], Closed) ) +# 30798 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos__1_ = _endpos__2_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1064 "src/ocaml/preprocess/parser_raw.mly" + ( mktyp ~loc:_sloc _1 ) +# 30807 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3746 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 30813 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24593,37 +30862,37 @@ module Tables = struct let _v : (Parsetree.module_expr Parsetree.open_infos * string Location.loc option) = let attrs2 = let _1 = _1_inlined2 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24599 "src/ocaml/preprocess/parser_raw.ml" +# 30868 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined2_ in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24608 "src/ocaml/preprocess/parser_raw.ml" +# 30877 "src/ocaml/preprocess/parser_raw.ml" in let override = -# 3933 "src/ocaml/preprocess/parser_raw.mly" +# 4129 "src/ocaml/preprocess/parser_raw.mly" ( Fresh ) -# 24614 "src/ocaml/preprocess/parser_raw.ml" +# 30883 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1675 "src/ocaml/preprocess/parser_raw.mly" +# 1740 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in let docs = symbol_docs _sloc in Opn.mk me ~override ~attrs ~loc ~docs, ext ) -# 24627 "src/ocaml/preprocess/parser_raw.ml" +# 30896 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24683,40 +30952,40 @@ module Tables = struct let _v : (Parsetree.module_expr Parsetree.open_infos * string Location.loc option) = let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24689 "src/ocaml/preprocess/parser_raw.ml" +# 30958 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in let attrs1 = let _1 = _1_inlined2 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24698 "src/ocaml/preprocess/parser_raw.ml" +# 30967 "src/ocaml/preprocess/parser_raw.ml" in let override = let _1 = _1_inlined1 in -# 3934 "src/ocaml/preprocess/parser_raw.mly" +# 4130 "src/ocaml/preprocess/parser_raw.mly" ( Override ) -# 24706 "src/ocaml/preprocess/parser_raw.ml" +# 30975 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1675 "src/ocaml/preprocess/parser_raw.mly" +# 1740 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in let docs = symbol_docs _sloc in Opn.mk me ~override ~attrs ~loc ~docs, ext ) -# 24720 "src/ocaml/preprocess/parser_raw.ml" +# 30989 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24769,9 +31038,9 @@ module Tables = struct let _v : (Longident.t Location.loc Parsetree.open_infos * string Location.loc option) = let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24775 "src/ocaml/preprocess/parser_raw.ml" +# 31044 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -24781,36 +31050,36 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 24787 "src/ocaml/preprocess/parser_raw.ml" +# 31056 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24795 "src/ocaml/preprocess/parser_raw.ml" +# 31064 "src/ocaml/preprocess/parser_raw.ml" in let override = -# 3933 "src/ocaml/preprocess/parser_raw.mly" +# 4129 "src/ocaml/preprocess/parser_raw.mly" ( Fresh ) -# 24801 "src/ocaml/preprocess/parser_raw.ml" +# 31070 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1690 "src/ocaml/preprocess/parser_raw.mly" +# 1755 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in let docs = symbol_docs _sloc in Opn.mk id ~override ~attrs ~loc ~docs, ext ) -# 24814 "src/ocaml/preprocess/parser_raw.ml" +# 31083 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24870,9 +31139,9 @@ module Tables = struct let _v : (Longident.t Location.loc Parsetree.open_infos * string Location.loc option) = let attrs2 = let _1 = _1_inlined4 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24876 "src/ocaml/preprocess/parser_raw.ml" +# 31145 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined4_ in @@ -24882,39 +31151,39 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 24888 "src/ocaml/preprocess/parser_raw.ml" +# 31157 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined2 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24896 "src/ocaml/preprocess/parser_raw.ml" +# 31165 "src/ocaml/preprocess/parser_raw.ml" in let override = let _1 = _1_inlined1 in -# 3934 "src/ocaml/preprocess/parser_raw.mly" +# 4130 "src/ocaml/preprocess/parser_raw.mly" ( Override ) -# 24904 "src/ocaml/preprocess/parser_raw.ml" +# 31173 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1690 "src/ocaml/preprocess/parser_raw.mly" +# 1755 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in let docs = symbol_docs _sloc in Opn.mk id ~override ~attrs ~loc ~docs, ext ) -# 24918 "src/ocaml/preprocess/parser_raw.ml" +# 31187 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24933,17 +31202,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 817 "src/ocaml/preprocess/parser_raw.mly" +# 862 "src/ocaml/preprocess/parser_raw.mly" (string) -# 24939 "src/ocaml/preprocess/parser_raw.ml" +# 31208 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3723 "src/ocaml/preprocess/parser_raw.mly" +# 3919 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24947 "src/ocaml/preprocess/parser_raw.ml" +# 31216 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24962,17 +31231,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 775 "src/ocaml/preprocess/parser_raw.mly" +# 820 "src/ocaml/preprocess/parser_raw.mly" (string) -# 24968 "src/ocaml/preprocess/parser_raw.ml" +# 31237 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3724 "src/ocaml/preprocess/parser_raw.mly" +# 3920 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 24976 "src/ocaml/preprocess/parser_raw.ml" +# 31245 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -24991,17 +31260,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 776 "src/ocaml/preprocess/parser_raw.mly" +# 821 "src/ocaml/preprocess/parser_raw.mly" (string) -# 24997 "src/ocaml/preprocess/parser_raw.ml" +# 31266 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3725 "src/ocaml/preprocess/parser_raw.mly" +# 3921 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25005 "src/ocaml/preprocess/parser_raw.ml" +# 31274 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25041,17 +31310,17 @@ module Tables = struct let _3 : (string) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 25047 "src/ocaml/preprocess/parser_raw.ml" +# 31316 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : (string) = -# 3726 "src/ocaml/preprocess/parser_raw.mly" +# 3922 "src/ocaml/preprocess/parser_raw.mly" ( "."^ _1 ^"(" ^ _3 ^ ")" ) -# 25055 "src/ocaml/preprocess/parser_raw.ml" +# 31324 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25098,17 +31367,17 @@ module Tables = struct let _3 : (string) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 25104 "src/ocaml/preprocess/parser_raw.ml" +# 31373 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in let _v : (string) = -# 3727 "src/ocaml/preprocess/parser_raw.mly" +# 3923 "src/ocaml/preprocess/parser_raw.mly" ( "."^ _1 ^ "(" ^ _3 ^ ")<-" ) -# 25112 "src/ocaml/preprocess/parser_raw.ml" +# 31381 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25148,17 +31417,17 @@ module Tables = struct let _3 : (string) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 25154 "src/ocaml/preprocess/parser_raw.ml" +# 31423 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : (string) = -# 3728 "src/ocaml/preprocess/parser_raw.mly" +# 3924 "src/ocaml/preprocess/parser_raw.mly" ( "."^ _1 ^"[" ^ _3 ^ "]" ) -# 25162 "src/ocaml/preprocess/parser_raw.ml" +# 31431 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25205,17 +31474,17 @@ module Tables = struct let _3 : (string) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 25211 "src/ocaml/preprocess/parser_raw.ml" +# 31480 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in let _v : (string) = -# 3729 "src/ocaml/preprocess/parser_raw.mly" +# 3925 "src/ocaml/preprocess/parser_raw.mly" ( "."^ _1 ^ "[" ^ _3 ^ "]<-" ) -# 25219 "src/ocaml/preprocess/parser_raw.ml" +# 31488 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25255,17 +31524,17 @@ module Tables = struct let _3 : (string) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 25261 "src/ocaml/preprocess/parser_raw.ml" +# 31530 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : (string) = -# 3730 "src/ocaml/preprocess/parser_raw.mly" +# 3926 "src/ocaml/preprocess/parser_raw.mly" ( "."^ _1 ^"{" ^ _3 ^ "}" ) -# 25269 "src/ocaml/preprocess/parser_raw.ml" +# 31538 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25312,17 +31581,17 @@ module Tables = struct let _3 : (string) = Obj.magic _3 in let _2 : unit = Obj.magic _2 in let _1 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 25318 "src/ocaml/preprocess/parser_raw.ml" +# 31587 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in let _v : (string) = -# 3731 "src/ocaml/preprocess/parser_raw.mly" +# 3927 "src/ocaml/preprocess/parser_raw.mly" ( "."^ _1 ^ "{" ^ _3 ^ "}<-" ) -# 25326 "src/ocaml/preprocess/parser_raw.ml" +# 31595 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25341,17 +31610,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 828 "src/ocaml/preprocess/parser_raw.mly" +# 873 "src/ocaml/preprocess/parser_raw.mly" (string) -# 25347 "src/ocaml/preprocess/parser_raw.ml" +# 31616 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3732 "src/ocaml/preprocess/parser_raw.mly" +# 3928 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25355 "src/ocaml/preprocess/parser_raw.ml" +# 31624 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25374,9 +31643,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3733 "src/ocaml/preprocess/parser_raw.mly" +# 3929 "src/ocaml/preprocess/parser_raw.mly" ( "!" ) -# 25380 "src/ocaml/preprocess/parser_raw.ml" +# 31649 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25395,22 +31664,22 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let op : ( -# 769 "src/ocaml/preprocess/parser_raw.mly" +# 814 "src/ocaml/preprocess/parser_raw.mly" (string) -# 25401 "src/ocaml/preprocess/parser_raw.ml" +# 31670 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic op in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_op_ in let _endpos = _endpos_op_ in let _v : (string) = let _1 = -# 3737 "src/ocaml/preprocess/parser_raw.mly" +# 3933 "src/ocaml/preprocess/parser_raw.mly" ( op ) -# 25409 "src/ocaml/preprocess/parser_raw.ml" +# 31678 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25414 "src/ocaml/preprocess/parser_raw.ml" +# 31683 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25429,22 +31698,22 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let op : ( -# 770 "src/ocaml/preprocess/parser_raw.mly" +# 815 "src/ocaml/preprocess/parser_raw.mly" (string) -# 25435 "src/ocaml/preprocess/parser_raw.ml" +# 31704 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic op in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_op_ in let _endpos = _endpos_op_ in let _v : (string) = let _1 = -# 3738 "src/ocaml/preprocess/parser_raw.mly" +# 3934 "src/ocaml/preprocess/parser_raw.mly" ( op ) -# 25443 "src/ocaml/preprocess/parser_raw.ml" +# 31712 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25448 "src/ocaml/preprocess/parser_raw.ml" +# 31717 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25463,22 +31732,22 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let op : ( -# 771 "src/ocaml/preprocess/parser_raw.mly" +# 816 "src/ocaml/preprocess/parser_raw.mly" (string) -# 25469 "src/ocaml/preprocess/parser_raw.ml" +# 31738 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic op in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_op_ in let _endpos = _endpos_op_ in let _v : (string) = let _1 = -# 3739 "src/ocaml/preprocess/parser_raw.mly" +# 3935 "src/ocaml/preprocess/parser_raw.mly" ( op ) -# 25477 "src/ocaml/preprocess/parser_raw.ml" +# 31746 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25482 "src/ocaml/preprocess/parser_raw.ml" +# 31751 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25497,22 +31766,22 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let op : ( -# 772 "src/ocaml/preprocess/parser_raw.mly" +# 817 "src/ocaml/preprocess/parser_raw.mly" (string) -# 25503 "src/ocaml/preprocess/parser_raw.ml" +# 31772 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic op in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_op_ in let _endpos = _endpos_op_ in let _v : (string) = let _1 = -# 3740 "src/ocaml/preprocess/parser_raw.mly" +# 3936 "src/ocaml/preprocess/parser_raw.mly" ( op ) -# 25511 "src/ocaml/preprocess/parser_raw.ml" +# 31780 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25516 "src/ocaml/preprocess/parser_raw.ml" +# 31785 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25531,22 +31800,22 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let op : ( -# 773 "src/ocaml/preprocess/parser_raw.mly" +# 818 "src/ocaml/preprocess/parser_raw.mly" (string) -# 25537 "src/ocaml/preprocess/parser_raw.ml" +# 31806 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic op in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_op_ in let _endpos = _endpos_op_ in let _v : (string) = let _1 = -# 3741 "src/ocaml/preprocess/parser_raw.mly" +# 3937 "src/ocaml/preprocess/parser_raw.mly" ( op ) -# 25545 "src/ocaml/preprocess/parser_raw.ml" +# 31814 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25550 "src/ocaml/preprocess/parser_raw.ml" +# 31819 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25569,14 +31838,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = let _1 = -# 3742 "src/ocaml/preprocess/parser_raw.mly" +# 3938 "src/ocaml/preprocess/parser_raw.mly" ("+") -# 25575 "src/ocaml/preprocess/parser_raw.ml" +# 31844 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25580 "src/ocaml/preprocess/parser_raw.ml" +# 31849 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25599,14 +31868,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = let _1 = -# 3743 "src/ocaml/preprocess/parser_raw.mly" +# 3939 "src/ocaml/preprocess/parser_raw.mly" ("+.") -# 25605 "src/ocaml/preprocess/parser_raw.ml" +# 31874 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25610 "src/ocaml/preprocess/parser_raw.ml" +# 31879 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25629,14 +31898,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = let _1 = -# 3744 "src/ocaml/preprocess/parser_raw.mly" +# 3940 "src/ocaml/preprocess/parser_raw.mly" ("+=") -# 25635 "src/ocaml/preprocess/parser_raw.ml" +# 31904 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25640 "src/ocaml/preprocess/parser_raw.ml" +# 31909 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25659,14 +31928,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = let _1 = -# 3745 "src/ocaml/preprocess/parser_raw.mly" +# 3941 "src/ocaml/preprocess/parser_raw.mly" ("-") -# 25665 "src/ocaml/preprocess/parser_raw.ml" +# 31934 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25670 "src/ocaml/preprocess/parser_raw.ml" +# 31939 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25689,14 +31958,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = let _1 = -# 3746 "src/ocaml/preprocess/parser_raw.mly" +# 3942 "src/ocaml/preprocess/parser_raw.mly" ("-.") -# 25695 "src/ocaml/preprocess/parser_raw.ml" +# 31964 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25700 "src/ocaml/preprocess/parser_raw.ml" +# 31969 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25719,14 +31988,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = let _1 = -# 3747 "src/ocaml/preprocess/parser_raw.mly" +# 3943 "src/ocaml/preprocess/parser_raw.mly" ("*") -# 25725 "src/ocaml/preprocess/parser_raw.ml" +# 31994 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25730 "src/ocaml/preprocess/parser_raw.ml" +# 31999 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25749,14 +32018,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = let _1 = -# 3748 "src/ocaml/preprocess/parser_raw.mly" +# 3944 "src/ocaml/preprocess/parser_raw.mly" ("%") -# 25755 "src/ocaml/preprocess/parser_raw.ml" +# 32024 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25760 "src/ocaml/preprocess/parser_raw.ml" +# 32029 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25779,14 +32048,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = let _1 = -# 3749 "src/ocaml/preprocess/parser_raw.mly" +# 3945 "src/ocaml/preprocess/parser_raw.mly" ("=") -# 25785 "src/ocaml/preprocess/parser_raw.ml" +# 32054 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25790 "src/ocaml/preprocess/parser_raw.ml" +# 32059 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25809,14 +32078,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = let _1 = -# 3750 "src/ocaml/preprocess/parser_raw.mly" +# 3946 "src/ocaml/preprocess/parser_raw.mly" ("<") -# 25815 "src/ocaml/preprocess/parser_raw.ml" +# 32084 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25820 "src/ocaml/preprocess/parser_raw.ml" +# 32089 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25839,14 +32108,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = let _1 = -# 3751 "src/ocaml/preprocess/parser_raw.mly" +# 3947 "src/ocaml/preprocess/parser_raw.mly" (">") -# 25845 "src/ocaml/preprocess/parser_raw.ml" +# 32114 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25850 "src/ocaml/preprocess/parser_raw.ml" +# 32119 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25869,14 +32138,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = let _1 = -# 3752 "src/ocaml/preprocess/parser_raw.mly" +# 3948 "src/ocaml/preprocess/parser_raw.mly" ("or") -# 25875 "src/ocaml/preprocess/parser_raw.ml" +# 32144 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25880 "src/ocaml/preprocess/parser_raw.ml" +# 32149 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25899,14 +32168,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = let _1 = -# 3753 "src/ocaml/preprocess/parser_raw.mly" +# 3949 "src/ocaml/preprocess/parser_raw.mly" ("||") -# 25905 "src/ocaml/preprocess/parser_raw.ml" +# 32174 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25910 "src/ocaml/preprocess/parser_raw.ml" +# 32179 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25929,14 +32198,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = let _1 = -# 3754 "src/ocaml/preprocess/parser_raw.mly" +# 3950 "src/ocaml/preprocess/parser_raw.mly" ("&") -# 25935 "src/ocaml/preprocess/parser_raw.ml" +# 32204 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25940 "src/ocaml/preprocess/parser_raw.ml" +# 32209 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25959,14 +32228,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = let _1 = -# 3755 "src/ocaml/preprocess/parser_raw.mly" +# 3951 "src/ocaml/preprocess/parser_raw.mly" ("&&") -# 25965 "src/ocaml/preprocess/parser_raw.ml" +# 32234 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 25970 "src/ocaml/preprocess/parser_raw.ml" +# 32239 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -25989,14 +32258,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = let _1 = -# 3756 "src/ocaml/preprocess/parser_raw.mly" +# 3952 "src/ocaml/preprocess/parser_raw.mly" (":=") -# 25995 "src/ocaml/preprocess/parser_raw.ml" +# 32264 "src/ocaml/preprocess/parser_raw.ml" in -# 3734 "src/ocaml/preprocess/parser_raw.mly" +# 3930 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 26000 "src/ocaml/preprocess/parser_raw.ml" +# 32269 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26019,9 +32288,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (bool) = -# 3636 "src/ocaml/preprocess/parser_raw.mly" +# 3832 "src/ocaml/preprocess/parser_raw.mly" ( true ) -# 26025 "src/ocaml/preprocess/parser_raw.ml" +# 32294 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26037,9 +32306,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (bool) = -# 3637 "src/ocaml/preprocess/parser_raw.mly" +# 3833 "src/ocaml/preprocess/parser_raw.mly" ( false ) -# 26043 "src/ocaml/preprocess/parser_raw.ml" +# 32312 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26057,7 +32326,7 @@ module Tables = struct let _v : (unit option) = # 114 "" ( None ) -# 26061 "src/ocaml/preprocess/parser_raw.ml" +# 32330 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26082,7 +32351,7 @@ module Tables = struct let _v : (unit option) = # 116 "" ( Some x ) -# 26086 "src/ocaml/preprocess/parser_raw.ml" +# 32355 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26100,7 +32369,7 @@ module Tables = struct let _v : (unit option) = # 114 "" ( None ) -# 26104 "src/ocaml/preprocess/parser_raw.ml" +# 32373 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26125,7 +32394,7 @@ module Tables = struct let _v : (unit option) = # 116 "" ( Some x ) -# 26129 "src/ocaml/preprocess/parser_raw.ml" +# 32398 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26143,7 +32412,7 @@ module Tables = struct let _v : (string Location.loc option) = # 114 "" ( None ) -# 26147 "src/ocaml/preprocess/parser_raw.ml" +# 32416 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26168,9 +32437,9 @@ module Tables = struct }; } = _menhir_stack in let _1_inlined1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 26174 "src/ocaml/preprocess/parser_raw.ml" +# 32443 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -26183,21 +32452,21 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 26189 "src/ocaml/preprocess/parser_raw.ml" +# 32458 "src/ocaml/preprocess/parser_raw.ml" in # 183 "" ( x ) -# 26195 "src/ocaml/preprocess/parser_raw.ml" +# 32464 "src/ocaml/preprocess/parser_raw.ml" in # 116 "" ( Some x ) -# 26201 "src/ocaml/preprocess/parser_raw.ml" +# 32470 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26215,7 +32484,7 @@ module Tables = struct let _v : (Parsetree.core_type option) = # 114 "" ( None ) -# 26219 "src/ocaml/preprocess/parser_raw.ml" +# 32488 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26247,12 +32516,12 @@ module Tables = struct let _v : (Parsetree.core_type option) = let x = # 183 "" ( x ) -# 26251 "src/ocaml/preprocess/parser_raw.ml" +# 32520 "src/ocaml/preprocess/parser_raw.ml" in # 116 "" ( Some x ) -# 26256 "src/ocaml/preprocess/parser_raw.ml" +# 32525 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26267,10 +32536,10 @@ module Tables = struct let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in - let _v : (Parsetree.expression option) = + let _v : (Parsetree.core_type option) = # 114 "" ( None ) -# 26274 "src/ocaml/preprocess/parser_raw.ml" +# 32543 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26294,20 +32563,215 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; }; } = _menhir_stack in - let x : (Parsetree.expression) = Obj.magic x in + let x : (Parsetree.core_type) = Obj.magic x in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos_x_ in - let _v : (Parsetree.expression option) = let x = + let _v : (Parsetree.core_type option) = let x = # 183 "" ( x ) -# 26306 "src/ocaml/preprocess/parser_raw.ml" +# 32575 "src/ocaml/preprocess/parser_raw.ml" in # 116 "" ( Some x ) -# 26311 "src/ocaml/preprocess/parser_raw.ml" +# 32580 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let _menhir_s = _menhir_env.MenhirLib.EngineTypes.current in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in + let _endpos = _startpos in + let _v : (Parsetree.expression option) = +# 114 "" + ( None ) +# 32598 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + } = _menhir_stack in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression option) = let x = + let x = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 32633 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 32638 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 183 "" + ( x ) +# 32644 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 116 "" + ( Some x ) +# 32650 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression option) = let x = + let x = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 32709 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 32714 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 32720 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 32731 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 32737 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 32757 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 32763 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 183 "" + ( x ) +# 32769 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 116 "" + ( Some x ) +# 32775 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26325,7 +32789,7 @@ module Tables = struct let _v : (Parsetree.module_type option) = # 114 "" ( None ) -# 26329 "src/ocaml/preprocess/parser_raw.ml" +# 32793 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26357,12 +32821,12 @@ module Tables = struct let _v : (Parsetree.module_type option) = let x = # 183 "" ( x ) -# 26361 "src/ocaml/preprocess/parser_raw.ml" +# 32825 "src/ocaml/preprocess/parser_raw.ml" in # 116 "" ( Some x ) -# 26366 "src/ocaml/preprocess/parser_raw.ml" +# 32830 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26380,7 +32844,7 @@ module Tables = struct let _v : (Parsetree.pattern option) = # 114 "" ( None ) -# 26384 "src/ocaml/preprocess/parser_raw.ml" +# 32848 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26412,12 +32876,12 @@ module Tables = struct let _v : (Parsetree.pattern option) = let x = # 183 "" ( x ) -# 26416 "src/ocaml/preprocess/parser_raw.ml" +# 32880 "src/ocaml/preprocess/parser_raw.ml" in # 116 "" ( Some x ) -# 26421 "src/ocaml/preprocess/parser_raw.ml" +# 32885 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26435,7 +32899,7 @@ module Tables = struct let _v : (Parsetree.expression option) = # 114 "" ( None ) -# 26439 "src/ocaml/preprocess/parser_raw.ml" +# 32903 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26467,12 +32931,12 @@ module Tables = struct let _v : (Parsetree.expression option) = let x = # 183 "" ( x ) -# 26471 "src/ocaml/preprocess/parser_raw.ml" +# 32935 "src/ocaml/preprocess/parser_raw.ml" in # 116 "" ( Some x ) -# 26476 "src/ocaml/preprocess/parser_raw.ml" +# 32940 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26487,10 +32951,10 @@ module Tables = struct let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in - let _v : ((Parsetree.core_type option * Parsetree.core_type option) option) = + let _v : (Parsetree.type_constraint option) = # 114 "" ( None ) -# 26494 "src/ocaml/preprocess/parser_raw.ml" +# 32958 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26508,14 +32972,14 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos_x_; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let x : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic x in + let x : (Parsetree.type_constraint) = Obj.magic x in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in - let _v : ((Parsetree.core_type option * Parsetree.core_type option) option) = + let _v : (Parsetree.type_constraint option) = # 116 "" ( Some x ) -# 26519 "src/ocaml/preprocess/parser_raw.ml" +# 32983 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26534,17 +32998,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 810 "src/ocaml/preprocess/parser_raw.mly" +# 855 "src/ocaml/preprocess/parser_raw.mly" (string) -# 26540 "src/ocaml/preprocess/parser_raw.ml" +# 33004 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3945 "src/ocaml/preprocess/parser_raw.mly" +# 4141 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 26548 "src/ocaml/preprocess/parser_raw.ml" +# 33012 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26574,20 +33038,356 @@ module Tables = struct }; }; } = _menhir_stack in - let _3 : unit = Obj.magic _3 in - let _2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" - (string) -# 26582 "src/ocaml/preprocess/parser_raw.ml" - ) = Obj.magic _2 in + let _3 : unit = Obj.magic _3 in + let _2 : ( +# 838 "src/ocaml/preprocess/parser_raw.mly" + (string) +# 33046 "src/ocaml/preprocess/parser_raw.ml" + ) = Obj.magic _2 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__3_ in + let _v : (string) = +# 4142 "src/ocaml/preprocess/parser_raw.mly" + ( _2 ) +# 33055 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = mty; + MenhirLib.EngineTypes.startp = _startpos_mty_; + MenhirLib.EngineTypes.endp = _endpos_mty_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = me; + MenhirLib.EngineTypes.startp = _startpos_me_; + MenhirLib.EngineTypes.endp = _endpos_me_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + } = _menhir_stack in + let _5 : unit = Obj.magic _5 in + let mty : (Parsetree.module_type) = Obj.magic mty in + let _3 : unit = Obj.magic _3 in + let me : (Parsetree.module_expr) = Obj.magic me in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__5_ in + let _v : (Parsetree.module_expr) = let _endpos = _endpos__5_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1509 "src/ocaml/preprocess/parser_raw.mly" + ( mkmod ~loc:_sloc (Pmod_constraint(me, mty)) ) +# 33111 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = me; + MenhirLib.EngineTypes.startp = _startpos_me_; + MenhirLib.EngineTypes.endp = _endpos_me_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _3 : unit = Obj.magic _3 in + let me : (Parsetree.module_expr) = Obj.magic me in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__3_ in + let _v : (Parsetree.module_expr) = +# 1516 "src/ocaml/preprocess/parser_raw.mly" + ( me (* TODO consider reloc *) ) +# 33150 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + } = _menhir_stack in + let _5 : unit = Obj.magic _5 in + let _1_inlined2 : (Parsetree.expression) = Obj.magic _1_inlined2 in + let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__5_ in + let _v : (Parsetree.module_expr) = let e = + let _1 = _1_inlined2 in + let e = + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 33206 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 33211 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 1539 "src/ocaml/preprocess/parser_raw.mly" + ( e ) +# 33217 "src/ocaml/preprocess/parser_raw.ml" + + in + let attrs = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 33225 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__5_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1524 "src/ocaml/preprocess/parser_raw.mly" + ( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) ) +# 33234 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined4; + MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + }; + }; + } = _menhir_stack in + let _5 : unit = Obj.magic _5 in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in + let _1_inlined3 : (string Location.loc option) = Obj.magic _1_inlined3 in + let _1_inlined2 : unit = Obj.magic _1_inlined2 in + let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__3_ in - let _v : (string) = -# 3946 "src/ocaml/preprocess/parser_raw.mly" - ( _2 ) -# 26591 "src/ocaml/preprocess/parser_raw.ml" + let _endpos = _endpos__5_ in + let _v : (Parsetree.module_expr) = let e = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined2_, _1_inlined4, _1_inlined3, _1_inlined2) in + let e = + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 33314 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 33319 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 33325 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 33336 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 33342 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 33362 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 33368 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 1539 "src/ocaml/preprocess/parser_raw.mly" + ( e ) +# 33374 "src/ocaml/preprocess/parser_raw.ml" + + in + let attrs = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 33382 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__5_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1524 "src/ocaml/preprocess/parser_raw.mly" + ( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) ) +# 33391 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26605,45 +33405,105 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = mty; - MenhirLib.EngineTypes.startp = _startpos_mty_; - MenhirLib.EngineTypes.endp = _endpos_mty_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _2_inlined1; + MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = me; - MenhirLib.EngineTypes.startp = _startpos_me_; - MenhirLib.EngineTypes.endp = _endpos_me_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; }; }; }; }; } = _menhir_stack in let _5 : unit = Obj.magic _5 in - let mty : (Parsetree.module_type) = Obj.magic mty in - let _3 : unit = Obj.magic _3 in - let me : (Parsetree.module_expr) = Obj.magic me in + let _1_inlined3 : (Parsetree.module_type) = Obj.magic _1_inlined3 in + let _2_inlined1 : unit = Obj.magic _2_inlined1 in + let _1_inlined2 : (Parsetree.expression) = Obj.magic _1_inlined2 in + let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in - let _v : (Parsetree.module_expr) = let _endpos = _endpos__5_ in + let _v : (Parsetree.module_expr) = let e = + let (_endpos__1_inlined1_, _startpos__1_inlined1_, _startpos__1_, _1_inlined1, _2, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _startpos__1_inlined2_, _1_inlined3, _2_inlined1, _1_inlined2) in + let ty = + let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 3807 "src/ocaml/preprocess/parser_raw.mly" + ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in + let descr = Ptyp_package (lid, cstrs) in + mktyp ~loc:_sloc ~attrs descr ) +# 33467 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos_ty_ = _endpos__1_inlined1_ in + let e = + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 33475 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 33480 "src/ocaml/preprocess/parser_raw.ml" + + in + let _startpos_e_ = _startpos__1_ in + let _endpos = _endpos_ty_ in + let _startpos = _startpos_e_ in + let _loc = (_startpos, _endpos) in + +# 1541 "src/ocaml/preprocess/parser_raw.mly" + ( ghexp ~loc:_loc (Pexp_constraint (e, ty)) ) +# 33490 "src/ocaml/preprocess/parser_raw.ml" + + in + let attrs = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 33498 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1448 "src/ocaml/preprocess/parser_raw.mly" - ( mkmod ~loc:_sloc (Pmod_constraint(me, mty)) ) -# 26647 "src/ocaml/preprocess/parser_raw.ml" +# 1524 "src/ocaml/preprocess/parser_raw.mly" + ( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) ) +# 33507 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26656,33 +33516,183 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = me; - MenhirLib.EngineTypes.startp = _startpos_me_; - MenhirLib.EngineTypes.endp = _endpos_me_; + MenhirLib.EngineTypes.semv = _1_inlined5; + MenhirLib.EngineTypes.startp = _startpos__1_inlined5_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined5_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2_inlined1; + MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined4; + MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + }; + }; }; }; } = _menhir_stack in - let _3 : unit = Obj.magic _3 in - let me : (Parsetree.module_expr) = Obj.magic me in + let _5 : unit = Obj.magic _5 in + let _1_inlined5 : (Parsetree.module_type) = Obj.magic _1_inlined5 in + let _2_inlined1 : unit = Obj.magic _2_inlined1 in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in + let _1_inlined3 : (string Location.loc option) = Obj.magic _1_inlined3 in + let _1_inlined2 : unit = Obj.magic _1_inlined2 in + let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__3_ in - let _v : (Parsetree.module_expr) = -# 1455 "src/ocaml/preprocess/parser_raw.mly" - ( me (* TODO consider reloc *) ) -# 26686 "src/ocaml/preprocess/parser_raw.ml" + let _endpos = _endpos__5_ in + let _v : (Parsetree.module_expr) = let e = + let (_endpos__1_inlined3_, _startpos__1_inlined3_, _startpos__1_, _1_inlined3, _2, _1_inlined2, _1_inlined1, _1) = (_endpos__1_inlined5_, _startpos__1_inlined5_, _startpos__1_inlined2_, _1_inlined5, _2_inlined1, _1_inlined4, _1_inlined3, _1_inlined2) in + let ty = + let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 3807 "src/ocaml/preprocess/parser_raw.mly" + ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in + let descr = Ptyp_package (lid, cstrs) in + mktyp ~loc:_sloc ~attrs descr ) +# 33604 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos_ty_ = _endpos__1_inlined3_ in + let e = + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 33615 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 33620 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 33626 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 33637 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 33643 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 33663 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 33669 "src/ocaml/preprocess/parser_raw.ml" + + in + let _startpos_e_ = _startpos__1_ in + let _endpos = _endpos_ty_ in + let _startpos = _startpos_e_ in + let _loc = (_startpos, _endpos) in + +# 1541 "src/ocaml/preprocess/parser_raw.mly" + ( ghexp ~loc:_loc (Pexp_constraint (e, ty)) ) +# 33679 "src/ocaml/preprocess/parser_raw.ml" + + in + let attrs = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 33687 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__5_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1524 "src/ocaml/preprocess/parser_raw.mly" + ( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) ) +# 33696 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26700,58 +33710,132 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e; - MenhirLib.EngineTypes.startp = _startpos_e_; - MenhirLib.EngineTypes.endp = _endpos_e_; + MenhirLib.EngineTypes.semv = _1_inlined4; + MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2_inlined1; + MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; }; }; }; }; } = _menhir_stack in let _5 : unit = Obj.magic _5 in - let e : (Parsetree.expression) = Obj.magic e in + let _1_inlined4 : (Parsetree.module_type) = Obj.magic _1_inlined4 in + let _4 : unit = Obj.magic _4 in + let _1_inlined3 : (Parsetree.module_type) = Obj.magic _1_inlined3 in + let _2_inlined1 : unit = Obj.magic _2_inlined1 in + let _1_inlined2 : (Parsetree.expression) = Obj.magic _1_inlined2 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in let _2 : unit = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in - let _v : (Parsetree.module_expr) = let e = -# 1478 "src/ocaml/preprocess/parser_raw.mly" - ( e ) -# 26739 "src/ocaml/preprocess/parser_raw.ml" - in + let _v : (Parsetree.module_expr) = let e = + let (_endpos__1_inlined2_, _startpos__1_inlined2_, _endpos__1_inlined1_, _startpos__1_inlined1_, _startpos__1_, _1_inlined2, _1_inlined1, _2, _1) = (_endpos__1_inlined4_, _startpos__1_inlined4_, _endpos__1_inlined3_, _startpos__1_inlined3_, _startpos__1_inlined2_, _1_inlined4, _1_inlined3, _2_inlined1, _1_inlined2) in + let ty2 = + let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 3807 "src/ocaml/preprocess/parser_raw.mly" + ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in + let descr = Ptyp_package (lid, cstrs) in + mktyp ~loc:_sloc ~attrs descr ) +# 33786 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos_ty2_ = _endpos__1_inlined2_ in + let ty1 = + let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 3807 "src/ocaml/preprocess/parser_raw.mly" + ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in + let descr = Ptyp_package (lid, cstrs) in + mktyp ~loc:_sloc ~attrs descr ) +# 33800 "src/ocaml/preprocess/parser_raw.ml" + + in + let e = + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 33807 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 33812 "src/ocaml/preprocess/parser_raw.ml" + + in + let _startpos_e_ = _startpos__1_ in + let _endpos = _endpos_ty2_ in + let _startpos = _startpos_e_ in + let _loc = (_startpos, _endpos) in + +# 1543 "src/ocaml/preprocess/parser_raw.mly" + ( ghexp ~loc:_loc (Pexp_coerce (e, Some ty1, ty2)) ) +# 33822 "src/ocaml/preprocess/parser_raw.ml" + + in let attrs = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 26746 "src/ocaml/preprocess/parser_raw.ml" +# 33830 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1463 "src/ocaml/preprocess/parser_raw.mly" +# 1524 "src/ocaml/preprocess/parser_raw.mly" ( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) ) -# 26755 "src/ocaml/preprocess/parser_raw.ml" +# 33839 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26769,35 +33853,65 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.semv = _1_inlined6; + MenhirLib.EngineTypes.startp = _startpos__1_inlined6_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined6_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2_inlined1; - MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e; - MenhirLib.EngineTypes.startp = _startpos_e_; - MenhirLib.EngineTypes.endp = _endpos_e_; + MenhirLib.EngineTypes.semv = _1_inlined5; + MenhirLib.EngineTypes.startp = _startpos__1_inlined5_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.semv = _2_inlined1; + MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined4; + MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; }; }; }; @@ -26806,9 +33920,14 @@ module Tables = struct }; } = _menhir_stack in let _5 : unit = Obj.magic _5 in - let _1_inlined2 : (Parsetree.module_type) = Obj.magic _1_inlined2 in + let _1_inlined6 : (Parsetree.module_type) = Obj.magic _1_inlined6 in + let _4 : unit = Obj.magic _4 in + let _1_inlined5 : (Parsetree.module_type) = Obj.magic _1_inlined5 in let _2_inlined1 : unit = Obj.magic _2_inlined1 in - let e : (Parsetree.expression) = Obj.magic e in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in + let _1_inlined3 : (string Location.loc option) = Obj.magic _1_inlined3 in + let _1_inlined2 : unit = Obj.magic _1_inlined2 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in let _2 : unit = Obj.magic _2 in let _1 : unit = Obj.magic _1 in @@ -26816,44 +33935,123 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in let _v : (Parsetree.module_expr) = let e = - let (_endpos__1_, _startpos__1_, _1, _2) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2, _2_inlined1) in - let ty = + let (_endpos__1_inlined4_, _startpos__1_inlined4_, _endpos__1_inlined3_, _startpos__1_inlined3_, _startpos__1_, _1_inlined4, _1_inlined3, _2, _1_inlined2, _1_inlined1, _1) = (_endpos__1_inlined6_, _startpos__1_inlined6_, _endpos__1_inlined5_, _startpos__1_inlined5_, _startpos__1_inlined2_, _1_inlined6, _1_inlined5, _2_inlined1, _1_inlined4, _1_inlined3, _1_inlined2) in + let ty2 = + let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined4_, _startpos__1_inlined4_, _1_inlined4) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3611 "src/ocaml/preprocess/parser_raw.mly" +# 3807 "src/ocaml/preprocess/parser_raw.mly" ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in let descr = Ptyp_package (lid, cstrs) in mktyp ~loc:_sloc ~attrs descr ) -# 26830 "src/ocaml/preprocess/parser_raw.ml" +# 33950 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos_ty_ = _endpos__1_ in - let _endpos = _endpos_ty_ in + let _endpos_ty2_ = _endpos__1_inlined4_ in + let ty1 = + let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 3807 "src/ocaml/preprocess/parser_raw.mly" + ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in + let descr = Ptyp_package (lid, cstrs) in + mktyp ~loc:_sloc ~attrs descr ) +# 33964 "src/ocaml/preprocess/parser_raw.ml" + + in + let e = + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 33974 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 33979 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 33985 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 33996 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 34002 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 34022 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 34028 "src/ocaml/preprocess/parser_raw.ml" + + in + let _startpos_e_ = _startpos__1_ in + let _endpos = _endpos_ty2_ in let _startpos = _startpos_e_ in let _loc = (_startpos, _endpos) in -# 1480 "src/ocaml/preprocess/parser_raw.mly" - ( ghexp ~loc:_loc (Pexp_constraint (e, ty)) ) -# 26840 "src/ocaml/preprocess/parser_raw.ml" +# 1543 "src/ocaml/preprocess/parser_raw.mly" + ( ghexp ~loc:_loc (Pexp_coerce (e, Some ty1, ty2)) ) +# 34038 "src/ocaml/preprocess/parser_raw.ml" in let attrs = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 26848 "src/ocaml/preprocess/parser_raw.ml" +# 34046 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1463 "src/ocaml/preprocess/parser_raw.mly" +# 1524 "src/ocaml/preprocess/parser_raw.mly" ( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) ) -# 26857 "src/ocaml/preprocess/parser_raw.ml" +# 34055 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -26876,9 +34074,9 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.semv = _2_inlined1; + MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _1_inlined2; @@ -26886,32 +34084,20 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2_inlined1; - MenhirLib.EngineTypes.startp = _startpos__2_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e; - MenhirLib.EngineTypes.startp = _startpos_e_; - MenhirLib.EngineTypes.endp = _endpos_e_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; }; }; @@ -26921,10 +34107,8 @@ module Tables = struct } = _menhir_stack in let _5 : unit = Obj.magic _5 in let _1_inlined3 : (Parsetree.module_type) = Obj.magic _1_inlined3 in - let _4 : unit = Obj.magic _4 in - let _1_inlined2 : (Parsetree.module_type) = Obj.magic _1_inlined2 in let _2_inlined1 : unit = Obj.magic _2_inlined1 in - let e : (Parsetree.expression) = Obj.magic e in + let _1_inlined2 : (Parsetree.expression) = Obj.magic _1_inlined2 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in let _2 : unit = Obj.magic _2 in let _1 : unit = Obj.magic _1 in @@ -26932,57 +34116,58 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in let _v : (Parsetree.module_expr) = let e = - let (_endpos__1_inlined1_, _startpos__1_inlined1_, _endpos__1_, _startpos__1_, _1_inlined1, _1, _2) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined3, _1_inlined2, _2_inlined1) in + let (_endpos__1_inlined1_, _startpos__1_inlined1_, _startpos__1_, _1_inlined1, _2, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _startpos__1_inlined2_, _1_inlined3, _2_inlined1, _1_inlined2) in let ty2 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3611 "src/ocaml/preprocess/parser_raw.mly" +# 3807 "src/ocaml/preprocess/parser_raw.mly" ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in let descr = Ptyp_package (lid, cstrs) in mktyp ~loc:_sloc ~attrs descr ) -# 26947 "src/ocaml/preprocess/parser_raw.ml" +# 34131 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_ty2_ = _endpos__1_inlined1_ in - let ty1 = - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in + let e = + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 34139 "src/ocaml/preprocess/parser_raw.ml" + in -# 3611 "src/ocaml/preprocess/parser_raw.mly" - ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in - let descr = Ptyp_package (lid, cstrs) in - mktyp ~loc:_sloc ~attrs descr ) -# 26960 "src/ocaml/preprocess/parser_raw.ml" +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 34144 "src/ocaml/preprocess/parser_raw.ml" in + let _startpos_e_ = _startpos__1_ in let _endpos = _endpos_ty2_ in let _startpos = _startpos_e_ in let _loc = (_startpos, _endpos) in -# 1482 "src/ocaml/preprocess/parser_raw.mly" - ( ghexp ~loc:_loc (Pexp_coerce (e, Some ty1, ty2)) ) -# 26969 "src/ocaml/preprocess/parser_raw.ml" +# 1545 "src/ocaml/preprocess/parser_raw.mly" + ( ghexp ~loc:_loc (Pexp_coerce (e, None, ty2)) ) +# 34154 "src/ocaml/preprocess/parser_raw.ml" in let attrs = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 26977 "src/ocaml/preprocess/parser_raw.ml" +# 34162 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1463 "src/ocaml/preprocess/parser_raw.mly" +# 1524 "src/ocaml/preprocess/parser_raw.mly" ( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) ) -# 26986 "src/ocaml/preprocess/parser_raw.ml" +# 34171 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27000,9 +34185,9 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined2; - MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.semv = _1_inlined5; + MenhirLib.EngineTypes.startp = _startpos__1_inlined5_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined5_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _2_inlined1; @@ -27010,25 +34195,43 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__2_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = e; - MenhirLib.EngineTypes.startp = _startpos_e_; - MenhirLib.EngineTypes.endp = _endpos_e_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.semv = _1_inlined4; + MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; }; }; }; @@ -27037,9 +34240,12 @@ module Tables = struct }; } = _menhir_stack in let _5 : unit = Obj.magic _5 in - let _1_inlined2 : (Parsetree.module_type) = Obj.magic _1_inlined2 in + let _1_inlined5 : (Parsetree.module_type) = Obj.magic _1_inlined5 in let _2_inlined1 : unit = Obj.magic _2_inlined1 in - let e : (Parsetree.expression) = Obj.magic e in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in + let _1_inlined3 : (string Location.loc option) = Obj.magic _1_inlined3 in + let _1_inlined2 : unit = Obj.magic _1_inlined2 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in let _2 : unit = Obj.magic _2 in let _1 : unit = Obj.magic _1 in @@ -27047,44 +34253,110 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in let _v : (Parsetree.module_expr) = let e = - let (_endpos__1_, _startpos__1_, _1, _2) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2, _2_inlined1) in + let (_endpos__1_inlined3_, _startpos__1_inlined3_, _startpos__1_, _1_inlined3, _2, _1_inlined2, _1_inlined1, _1) = (_endpos__1_inlined5_, _startpos__1_inlined5_, _startpos__1_inlined2_, _1_inlined5, _2_inlined1, _1_inlined4, _1_inlined3, _1_inlined2) in let ty2 = + let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3611 "src/ocaml/preprocess/parser_raw.mly" +# 3807 "src/ocaml/preprocess/parser_raw.mly" ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in let descr = Ptyp_package (lid, cstrs) in mktyp ~loc:_sloc ~attrs descr ) -# 27061 "src/ocaml/preprocess/parser_raw.ml" +# 34268 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos_ty2_ = _endpos__1_ in + let _endpos_ty2_ = _endpos__1_inlined3_ in + let e = + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 34279 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 34284 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 34290 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 34301 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 34307 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 34327 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 34333 "src/ocaml/preprocess/parser_raw.ml" + + in + let _startpos_e_ = _startpos__1_ in let _endpos = _endpos_ty2_ in let _startpos = _startpos_e_ in let _loc = (_startpos, _endpos) in -# 1484 "src/ocaml/preprocess/parser_raw.mly" +# 1545 "src/ocaml/preprocess/parser_raw.mly" ( ghexp ~loc:_loc (Pexp_coerce (e, None, ty2)) ) -# 27071 "src/ocaml/preprocess/parser_raw.ml" +# 34343 "src/ocaml/preprocess/parser_raw.ml" in let attrs = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27079 "src/ocaml/preprocess/parser_raw.ml" +# 34351 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1463 "src/ocaml/preprocess/parser_raw.mly" +# 1524 "src/ocaml/preprocess/parser_raw.mly" ( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) ) -# 27088 "src/ocaml/preprocess/parser_raw.ml" +# 34360 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27114,9 +34386,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Longident.t) = -# 1360 "src/ocaml/preprocess/parser_raw.mly" +# 1418 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27120 "src/ocaml/preprocess/parser_raw.ml" +# 34392 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27146,9 +34418,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Longident.t) = -# 1345 "src/ocaml/preprocess/parser_raw.mly" +# 1403 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27152 "src/ocaml/preprocess/parser_raw.ml" +# 34424 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27178,9 +34450,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.core_type) = -# 1320 "src/ocaml/preprocess/parser_raw.mly" +# 1378 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27184 "src/ocaml/preprocess/parser_raw.ml" +# 34456 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27210,9 +34482,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.expression) = -# 1325 "src/ocaml/preprocess/parser_raw.mly" +# 1383 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27216 "src/ocaml/preprocess/parser_raw.ml" +# 34488 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27242,9 +34514,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Longident.t) = -# 1350 "src/ocaml/preprocess/parser_raw.mly" +# 1408 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27248 "src/ocaml/preprocess/parser_raw.ml" +# 34520 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27274,9 +34546,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Longident.t) = -# 1355 "src/ocaml/preprocess/parser_raw.mly" +# 1413 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27280 "src/ocaml/preprocess/parser_raw.ml" +# 34552 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27306,9 +34578,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.module_expr) = -# 1315 "src/ocaml/preprocess/parser_raw.mly" +# 1373 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27312 "src/ocaml/preprocess/parser_raw.ml" +# 34584 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27338,9 +34610,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.module_type) = -# 1310 "src/ocaml/preprocess/parser_raw.mly" +# 1368 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27344 "src/ocaml/preprocess/parser_raw.ml" +# 34616 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27370,9 +34642,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Longident.t) = -# 1335 "src/ocaml/preprocess/parser_raw.mly" +# 1393 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27376 "src/ocaml/preprocess/parser_raw.ml" +# 34648 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27402,9 +34674,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.pattern) = -# 1330 "src/ocaml/preprocess/parser_raw.mly" +# 1388 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27408 "src/ocaml/preprocess/parser_raw.ml" +# 34680 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27434,9 +34706,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Longident.t) = -# 1340 "src/ocaml/preprocess/parser_raw.mly" +# 1398 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27440 "src/ocaml/preprocess/parser_raw.ml" +# 34712 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27478,15 +34750,15 @@ module Tables = struct let _loc__2_ = (_startpos__2_, _endpos__2_) in let _sloc = (_symbolstartpos, _endpos) in -# 2891 "src/ocaml/preprocess/parser_raw.mly" +# 3031 "src/ocaml/preprocess/parser_raw.mly" ( mkpat_cons ~loc:_sloc _loc__2_ (ghpat ~loc:_sloc (Ppat_tuple[_1;_3])) ) -# 27484 "src/ocaml/preprocess/parser_raw.ml" +# 34756 "src/ocaml/preprocess/parser_raw.ml" in -# 2879 "src/ocaml/preprocess/parser_raw.mly" +# 3019 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27490 "src/ocaml/preprocess/parser_raw.ml" +# 34762 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27516,14 +34788,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.pattern) = let _1 = -# 2893 "src/ocaml/preprocess/parser_raw.mly" +# 3033 "src/ocaml/preprocess/parser_raw.mly" ( Pat.attr _1 _2 ) -# 27522 "src/ocaml/preprocess/parser_raw.ml" +# 34794 "src/ocaml/preprocess/parser_raw.ml" in -# 2879 "src/ocaml/preprocess/parser_raw.mly" +# 3019 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27527 "src/ocaml/preprocess/parser_raw.ml" +# 34799 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27546,14 +34818,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = let _1 = -# 2895 "src/ocaml/preprocess/parser_raw.mly" +# 3035 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27552 "src/ocaml/preprocess/parser_raw.ml" +# 34824 "src/ocaml/preprocess/parser_raw.ml" in -# 2879 "src/ocaml/preprocess/parser_raw.mly" +# 3019 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27557 "src/ocaml/preprocess/parser_raw.ml" +# 34829 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27598,15 +34870,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 27604 "src/ocaml/preprocess/parser_raw.ml" +# 34876 "src/ocaml/preprocess/parser_raw.ml" in -# 2898 "src/ocaml/preprocess/parser_raw.mly" +# 3038 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_alias(_1, _3) ) -# 27610 "src/ocaml/preprocess/parser_raw.ml" +# 34882 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -27614,21 +34886,21 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 27620 "src/ocaml/preprocess/parser_raw.ml" +# 34892 "src/ocaml/preprocess/parser_raw.ml" in -# 2909 "src/ocaml/preprocess/parser_raw.mly" +# 3049 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27626 "src/ocaml/preprocess/parser_raw.ml" +# 34898 "src/ocaml/preprocess/parser_raw.ml" in -# 2879 "src/ocaml/preprocess/parser_raw.mly" +# 3019 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27632 "src/ocaml/preprocess/parser_raw.ml" +# 34904 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27653,29 +34925,29 @@ module Tables = struct let _v : (Parsetree.pattern) = let _1 = let _1 = let _1 = -# 2902 "src/ocaml/preprocess/parser_raw.mly" +# 3042 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_tuple(List.rev _1) ) -# 27659 "src/ocaml/preprocess/parser_raw.ml" +# 34931 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 27667 "src/ocaml/preprocess/parser_raw.ml" +# 34939 "src/ocaml/preprocess/parser_raw.ml" in -# 2909 "src/ocaml/preprocess/parser_raw.mly" +# 3049 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27673 "src/ocaml/preprocess/parser_raw.ml" +# 34945 "src/ocaml/preprocess/parser_raw.ml" in -# 2879 "src/ocaml/preprocess/parser_raw.mly" +# 3019 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27679 "src/ocaml/preprocess/parser_raw.ml" +# 34951 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27714,30 +34986,30 @@ module Tables = struct let _v : (Parsetree.pattern) = let _1 = let _1 = let _1 = -# 2906 "src/ocaml/preprocess/parser_raw.mly" +# 3046 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_or(_1, _3) ) -# 27720 "src/ocaml/preprocess/parser_raw.ml" +# 34992 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 27729 "src/ocaml/preprocess/parser_raw.ml" +# 35001 "src/ocaml/preprocess/parser_raw.ml" in -# 2909 "src/ocaml/preprocess/parser_raw.mly" +# 3049 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27735 "src/ocaml/preprocess/parser_raw.ml" +# 35007 "src/ocaml/preprocess/parser_raw.ml" in -# 2879 "src/ocaml/preprocess/parser_raw.mly" +# 3019 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27741 "src/ocaml/preprocess/parser_raw.ml" +# 35013 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27785,24 +35057,24 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27791 "src/ocaml/preprocess/parser_raw.ml" +# 35063 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 27797 "src/ocaml/preprocess/parser_raw.ml" +# 35069 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__3_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2881 "src/ocaml/preprocess/parser_raw.mly" +# 3021 "src/ocaml/preprocess/parser_raw.mly" ( mkpat_attrs ~loc:_sloc (Ppat_exception _3) _2) -# 27806 "src/ocaml/preprocess/parser_raw.ml" +# 35078 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27839,9 +35111,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.pattern list) = -# 3012 "src/ocaml/preprocess/parser_raw.mly" +# 3152 "src/ocaml/preprocess/parser_raw.mly" ( _3 :: _1 ) -# 27845 "src/ocaml/preprocess/parser_raw.ml" +# 35117 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27878,9 +35150,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.pattern list) = -# 3013 "src/ocaml/preprocess/parser_raw.mly" +# 3153 "src/ocaml/preprocess/parser_raw.mly" ( [_3; _1] ) -# 27884 "src/ocaml/preprocess/parser_raw.ml" +# 35156 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27917,9 +35189,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.pattern list) = -# 3012 "src/ocaml/preprocess/parser_raw.mly" +# 3152 "src/ocaml/preprocess/parser_raw.mly" ( _3 :: _1 ) -# 27923 "src/ocaml/preprocess/parser_raw.ml" +# 35195 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27956,9 +35228,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (Parsetree.pattern list) = -# 3013 "src/ocaml/preprocess/parser_raw.mly" +# 3153 "src/ocaml/preprocess/parser_raw.mly" ( [_3; _1] ) -# 27962 "src/ocaml/preprocess/parser_raw.ml" +# 35234 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -27981,9 +35253,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = -# 2914 "src/ocaml/preprocess/parser_raw.mly" +# 3054 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 27987 "src/ocaml/preprocess/parser_raw.ml" +# 35259 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28019,15 +35291,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 28025 "src/ocaml/preprocess/parser_raw.ml" +# 35297 "src/ocaml/preprocess/parser_raw.ml" in -# 2917 "src/ocaml/preprocess/parser_raw.mly" +# 3057 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_construct(_1, Some ([], _2)) ) -# 28031 "src/ocaml/preprocess/parser_raw.ml" +# 35303 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__2_ in @@ -28035,15 +35307,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 28041 "src/ocaml/preprocess/parser_raw.ml" +# 35313 "src/ocaml/preprocess/parser_raw.ml" in -# 2923 "src/ocaml/preprocess/parser_raw.mly" +# 3063 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28047 "src/ocaml/preprocess/parser_raw.ml" +# 35319 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28103,24 +35375,24 @@ module Tables = struct let _v : (Parsetree.pattern) = let _1 = let _1 = let newtypes = -# 2662 "src/ocaml/preprocess/parser_raw.mly" +# 2774 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 28109 "src/ocaml/preprocess/parser_raw.ml" +# 35381 "src/ocaml/preprocess/parser_raw.ml" in let constr = let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 28118 "src/ocaml/preprocess/parser_raw.ml" +# 35390 "src/ocaml/preprocess/parser_raw.ml" in -# 2920 "src/ocaml/preprocess/parser_raw.mly" +# 3060 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_construct(constr, Some (newtypes, pat)) ) -# 28124 "src/ocaml/preprocess/parser_raw.ml" +# 35396 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos_pat_ in @@ -28128,15 +35400,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 28134 "src/ocaml/preprocess/parser_raw.ml" +# 35406 "src/ocaml/preprocess/parser_raw.ml" in -# 2923 "src/ocaml/preprocess/parser_raw.mly" +# 3063 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28140 "src/ocaml/preprocess/parser_raw.ml" +# 35412 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28167,24 +35439,24 @@ module Tables = struct let _endpos = _endpos__2_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2922 "src/ocaml/preprocess/parser_raw.mly" +# 3062 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_variant(_1, Some _2) ) -# 28173 "src/ocaml/preprocess/parser_raw.ml" +# 35445 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 28182 "src/ocaml/preprocess/parser_raw.ml" +# 35454 "src/ocaml/preprocess/parser_raw.ml" in -# 2923 "src/ocaml/preprocess/parser_raw.mly" +# 3063 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28188 "src/ocaml/preprocess/parser_raw.ml" +# 35460 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28232,24 +35504,24 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28238 "src/ocaml/preprocess/parser_raw.ml" +# 35510 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 28244 "src/ocaml/preprocess/parser_raw.ml" +# 35516 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__3_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2925 "src/ocaml/preprocess/parser_raw.mly" +# 3065 "src/ocaml/preprocess/parser_raw.mly" ( mkpat_attrs ~loc:_sloc (Ppat_lazy _3) _2) -# 28253 "src/ocaml/preprocess/parser_raw.ml" +# 35525 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28291,15 +35563,15 @@ module Tables = struct let _loc__2_ = (_startpos__2_, _endpos__2_) in let _sloc = (_symbolstartpos, _endpos) in -# 2891 "src/ocaml/preprocess/parser_raw.mly" +# 3031 "src/ocaml/preprocess/parser_raw.mly" ( mkpat_cons ~loc:_sloc _loc__2_ (ghpat ~loc:_sloc (Ppat_tuple[_1;_3])) ) -# 28297 "src/ocaml/preprocess/parser_raw.ml" +# 35569 "src/ocaml/preprocess/parser_raw.ml" in -# 2886 "src/ocaml/preprocess/parser_raw.mly" +# 3026 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28303 "src/ocaml/preprocess/parser_raw.ml" +# 35575 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28329,14 +35601,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.pattern) = let _1 = -# 2893 "src/ocaml/preprocess/parser_raw.mly" +# 3033 "src/ocaml/preprocess/parser_raw.mly" ( Pat.attr _1 _2 ) -# 28335 "src/ocaml/preprocess/parser_raw.ml" +# 35607 "src/ocaml/preprocess/parser_raw.ml" in -# 2886 "src/ocaml/preprocess/parser_raw.mly" +# 3026 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28340 "src/ocaml/preprocess/parser_raw.ml" +# 35612 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28359,14 +35631,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = let _1 = -# 2895 "src/ocaml/preprocess/parser_raw.mly" +# 3035 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28365 "src/ocaml/preprocess/parser_raw.ml" +# 35637 "src/ocaml/preprocess/parser_raw.ml" in -# 2886 "src/ocaml/preprocess/parser_raw.mly" +# 3026 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28370 "src/ocaml/preprocess/parser_raw.ml" +# 35642 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28411,15 +35683,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 28417 "src/ocaml/preprocess/parser_raw.ml" +# 35689 "src/ocaml/preprocess/parser_raw.ml" in -# 2898 "src/ocaml/preprocess/parser_raw.mly" +# 3038 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_alias(_1, _3) ) -# 28423 "src/ocaml/preprocess/parser_raw.ml" +# 35695 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -28427,21 +35699,21 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 28433 "src/ocaml/preprocess/parser_raw.ml" +# 35705 "src/ocaml/preprocess/parser_raw.ml" in -# 2909 "src/ocaml/preprocess/parser_raw.mly" +# 3049 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28439 "src/ocaml/preprocess/parser_raw.ml" +# 35711 "src/ocaml/preprocess/parser_raw.ml" in -# 2886 "src/ocaml/preprocess/parser_raw.mly" +# 3026 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28445 "src/ocaml/preprocess/parser_raw.ml" +# 35717 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28466,29 +35738,29 @@ module Tables = struct let _v : (Parsetree.pattern) = let _1 = let _1 = let _1 = -# 2902 "src/ocaml/preprocess/parser_raw.mly" +# 3042 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_tuple(List.rev _1) ) -# 28472 "src/ocaml/preprocess/parser_raw.ml" +# 35744 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 28480 "src/ocaml/preprocess/parser_raw.ml" +# 35752 "src/ocaml/preprocess/parser_raw.ml" in -# 2909 "src/ocaml/preprocess/parser_raw.mly" +# 3049 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28486 "src/ocaml/preprocess/parser_raw.ml" +# 35758 "src/ocaml/preprocess/parser_raw.ml" in -# 2886 "src/ocaml/preprocess/parser_raw.mly" +# 3026 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28492 "src/ocaml/preprocess/parser_raw.ml" +# 35764 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28527,30 +35799,30 @@ module Tables = struct let _v : (Parsetree.pattern) = let _1 = let _1 = let _1 = -# 2906 "src/ocaml/preprocess/parser_raw.mly" +# 3046 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_or(_1, _3) ) -# 28533 "src/ocaml/preprocess/parser_raw.ml" +# 35805 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 28542 "src/ocaml/preprocess/parser_raw.ml" +# 35814 "src/ocaml/preprocess/parser_raw.ml" in -# 2909 "src/ocaml/preprocess/parser_raw.mly" +# 3049 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28548 "src/ocaml/preprocess/parser_raw.ml" +# 35820 "src/ocaml/preprocess/parser_raw.ml" in -# 2886 "src/ocaml/preprocess/parser_raw.mly" +# 3026 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28554 "src/ocaml/preprocess/parser_raw.ml" +# 35826 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28569,9 +35841,9 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 28575 "src/ocaml/preprocess/parser_raw.ml" +# 35847 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -28583,30 +35855,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 28589 "src/ocaml/preprocess/parser_raw.ml" +# 35861 "src/ocaml/preprocess/parser_raw.ml" in -# 2344 "src/ocaml/preprocess/parser_raw.mly" +# 2450 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_var _1 ) -# 28595 "src/ocaml/preprocess/parser_raw.ml" +# 35867 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 28604 "src/ocaml/preprocess/parser_raw.ml" +# 35876 "src/ocaml/preprocess/parser_raw.ml" in -# 2346 "src/ocaml/preprocess/parser_raw.mly" +# 2452 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28610 "src/ocaml/preprocess/parser_raw.ml" +# 35882 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28630,23 +35902,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2345 "src/ocaml/preprocess/parser_raw.mly" +# 2451 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_any ) -# 28636 "src/ocaml/preprocess/parser_raw.ml" +# 35908 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 28644 "src/ocaml/preprocess/parser_raw.ml" +# 35916 "src/ocaml/preprocess/parser_raw.ml" in -# 2346 "src/ocaml/preprocess/parser_raw.mly" +# 2452 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28650 "src/ocaml/preprocess/parser_raw.ml" +# 35922 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28669,9 +35941,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.payload) = -# 4057 "src/ocaml/preprocess/parser_raw.mly" +# 4253 "src/ocaml/preprocess/parser_raw.mly" ( PStr _1 ) -# 28675 "src/ocaml/preprocess/parser_raw.ml" +# 35947 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28701,9 +35973,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.payload) = -# 4058 "src/ocaml/preprocess/parser_raw.mly" +# 4254 "src/ocaml/preprocess/parser_raw.mly" ( PSig _2 ) -# 28707 "src/ocaml/preprocess/parser_raw.ml" +# 35979 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28733,9 +36005,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.payload) = -# 4059 "src/ocaml/preprocess/parser_raw.mly" +# 4255 "src/ocaml/preprocess/parser_raw.mly" ( PTyp _2 ) -# 28739 "src/ocaml/preprocess/parser_raw.ml" +# 36011 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28765,9 +36037,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.payload) = -# 4060 "src/ocaml/preprocess/parser_raw.mly" +# 4256 "src/ocaml/preprocess/parser_raw.mly" ( PPat (_2, None) ) -# 28771 "src/ocaml/preprocess/parser_raw.ml" +# 36043 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28811,9 +36083,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : (Parsetree.payload) = -# 4061 "src/ocaml/preprocess/parser_raw.mly" +# 4257 "src/ocaml/preprocess/parser_raw.mly" ( PPat (_2, Some _4) ) -# 28817 "src/ocaml/preprocess/parser_raw.ml" +# 36089 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28836,9 +36108,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.core_type) = -# 3450 "src/ocaml/preprocess/parser_raw.mly" +# 3590 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28842 "src/ocaml/preprocess/parser_raw.ml" +# 36114 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28881,24 +36153,24 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 28885 "src/ocaml/preprocess/parser_raw.ml" +# 36157 "src/ocaml/preprocess/parser_raw.ml" in -# 1092 "src/ocaml/preprocess/parser_raw.mly" +# 1129 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 28890 "src/ocaml/preprocess/parser_raw.ml" +# 36162 "src/ocaml/preprocess/parser_raw.ml" in -# 3442 "src/ocaml/preprocess/parser_raw.mly" +# 3582 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28896 "src/ocaml/preprocess/parser_raw.ml" +# 36168 "src/ocaml/preprocess/parser_raw.ml" in -# 3446 "src/ocaml/preprocess/parser_raw.mly" +# 3586 "src/ocaml/preprocess/parser_raw.mly" ( Ptyp_poly(_1, _3) ) -# 28902 "src/ocaml/preprocess/parser_raw.ml" +# 36174 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos__3_, _startpos_xs_) in @@ -28906,15 +36178,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 28912 "src/ocaml/preprocess/parser_raw.ml" +# 36184 "src/ocaml/preprocess/parser_raw.ml" in -# 3452 "src/ocaml/preprocess/parser_raw.mly" +# 3592 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28918 "src/ocaml/preprocess/parser_raw.ml" +# 36190 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28937,14 +36209,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.core_type) = let _1 = -# 3481 "src/ocaml/preprocess/parser_raw.mly" +# 3621 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28943 "src/ocaml/preprocess/parser_raw.ml" +# 36215 "src/ocaml/preprocess/parser_raw.ml" in -# 3450 "src/ocaml/preprocess/parser_raw.mly" +# 3590 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28948 "src/ocaml/preprocess/parser_raw.ml" +# 36220 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -28983,33 +36255,33 @@ module Tables = struct let _v : (Parsetree.core_type) = let _1 = let _1 = let _3 = -# 3481 "src/ocaml/preprocess/parser_raw.mly" +# 3621 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 28989 "src/ocaml/preprocess/parser_raw.ml" +# 36261 "src/ocaml/preprocess/parser_raw.ml" in let _1 = let _1 = let xs = # 253 "" ( List.rev xs ) -# 28996 "src/ocaml/preprocess/parser_raw.ml" +# 36268 "src/ocaml/preprocess/parser_raw.ml" in -# 1092 "src/ocaml/preprocess/parser_raw.mly" +# 1129 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 29001 "src/ocaml/preprocess/parser_raw.ml" +# 36273 "src/ocaml/preprocess/parser_raw.ml" in -# 3442 "src/ocaml/preprocess/parser_raw.mly" +# 3582 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 29007 "src/ocaml/preprocess/parser_raw.ml" +# 36279 "src/ocaml/preprocess/parser_raw.ml" in -# 3446 "src/ocaml/preprocess/parser_raw.mly" +# 3586 "src/ocaml/preprocess/parser_raw.mly" ( Ptyp_poly(_1, _3) ) -# 29013 "src/ocaml/preprocess/parser_raw.ml" +# 36285 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__1_ = _startpos_xs_ in @@ -29017,15 +36289,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 29023 "src/ocaml/preprocess/parser_raw.ml" +# 36295 "src/ocaml/preprocess/parser_raw.ml" in -# 3452 "src/ocaml/preprocess/parser_raw.mly" +# 3592 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 29029 "src/ocaml/preprocess/parser_raw.ml" +# 36301 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29072,9 +36344,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 4018 "src/ocaml/preprocess/parser_raw.mly" - ( Attr.mk ~loc:(make_loc _sloc) _2 _3 ) -# 29078 "src/ocaml/preprocess/parser_raw.ml" +# 4214 "src/ocaml/preprocess/parser_raw.mly" + ( mk_attr ~loc:(make_loc _sloc) _2 _3 ) +# 36350 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29155,9 +36427,9 @@ module Tables = struct let _v : (Parsetree.value_description * string Location.loc option) = let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 29161 "src/ocaml/preprocess/parser_raw.ml" +# 36433 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -29167,30 +36439,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 29173 "src/ocaml/preprocess/parser_raw.ml" +# 36445 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 29181 "src/ocaml/preprocess/parser_raw.ml" +# 36453 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3076 "src/ocaml/preprocess/parser_raw.mly" +# 3216 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in let docs = symbol_docs _sloc in Val.mk id ty ~prim ~attrs ~loc ~docs, ext ) -# 29194 "src/ocaml/preprocess/parser_raw.ml" +# 36466 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29206,14 +36478,14 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Asttypes.private_flag) = let _1 = -# 3886 "src/ocaml/preprocess/parser_raw.mly" +# 4082 "src/ocaml/preprocess/parser_raw.mly" ( Public ) -# 29212 "src/ocaml/preprocess/parser_raw.ml" +# 36484 "src/ocaml/preprocess/parser_raw.ml" in -# 3883 "src/ocaml/preprocess/parser_raw.mly" +# 4079 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 29217 "src/ocaml/preprocess/parser_raw.ml" +# 36489 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29236,14 +36508,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.private_flag) = let _1 = -# 3887 "src/ocaml/preprocess/parser_raw.mly" +# 4083 "src/ocaml/preprocess/parser_raw.mly" ( Private ) -# 29242 "src/ocaml/preprocess/parser_raw.ml" +# 36514 "src/ocaml/preprocess/parser_raw.ml" in -# 3883 "src/ocaml/preprocess/parser_raw.mly" +# 4079 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 29247 "src/ocaml/preprocess/parser_raw.ml" +# 36519 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29259,9 +36531,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Asttypes.private_flag * Asttypes.virtual_flag) = -# 3909 "src/ocaml/preprocess/parser_raw.mly" +# 4105 "src/ocaml/preprocess/parser_raw.mly" ( Public, Concrete ) -# 29265 "src/ocaml/preprocess/parser_raw.ml" +# 36537 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29284,9 +36556,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.private_flag * Asttypes.virtual_flag) = -# 3910 "src/ocaml/preprocess/parser_raw.mly" +# 4106 "src/ocaml/preprocess/parser_raw.mly" ( Private, Concrete ) -# 29290 "src/ocaml/preprocess/parser_raw.ml" +# 36562 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29309,9 +36581,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.private_flag * Asttypes.virtual_flag) = -# 3911 "src/ocaml/preprocess/parser_raw.mly" +# 4107 "src/ocaml/preprocess/parser_raw.mly" ( Public, Virtual ) -# 29315 "src/ocaml/preprocess/parser_raw.ml" +# 36587 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29341,9 +36613,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.private_flag * Asttypes.virtual_flag) = -# 3912 "src/ocaml/preprocess/parser_raw.mly" +# 4108 "src/ocaml/preprocess/parser_raw.mly" ( Private, Virtual ) -# 29347 "src/ocaml/preprocess/parser_raw.ml" +# 36619 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29373,9 +36645,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.private_flag * Asttypes.virtual_flag) = -# 3913 "src/ocaml/preprocess/parser_raw.mly" +# 4109 "src/ocaml/preprocess/parser_raw.mly" ( Private, Virtual ) -# 29379 "src/ocaml/preprocess/parser_raw.ml" +# 36651 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29391,9 +36663,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Asttypes.rec_flag) = -# 3864 "src/ocaml/preprocess/parser_raw.mly" +# 4060 "src/ocaml/preprocess/parser_raw.mly" ( Nonrecursive ) -# 29397 "src/ocaml/preprocess/parser_raw.ml" +# 36669 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29416,9 +36688,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.rec_flag) = -# 3865 "src/ocaml/preprocess/parser_raw.mly" +# 4061 "src/ocaml/preprocess/parser_raw.mly" ( Recursive ) -# 29422 "src/ocaml/preprocess/parser_raw.ml" +# 36694 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29444,12 +36716,12 @@ module Tables = struct (Longident.t Location.loc * Parsetree.expression) list) = let eo = # 124 "" ( None ) -# 29448 "src/ocaml/preprocess/parser_raw.ml" +# 36720 "src/ocaml/preprocess/parser_raw.ml" in -# 2811 "src/ocaml/preprocess/parser_raw.mly" +# 2951 "src/ocaml/preprocess/parser_raw.mly" ( eo, fields ) -# 29453 "src/ocaml/preprocess/parser_raw.ml" +# 36725 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29490,18 +36762,18 @@ module Tables = struct let x = # 191 "" ( x ) -# 29494 "src/ocaml/preprocess/parser_raw.ml" +# 36766 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 29499 "src/ocaml/preprocess/parser_raw.ml" +# 36771 "src/ocaml/preprocess/parser_raw.ml" in -# 2811 "src/ocaml/preprocess/parser_raw.mly" +# 2951 "src/ocaml/preprocess/parser_raw.mly" ( eo, fields ) -# 29505 "src/ocaml/preprocess/parser_raw.ml" +# 36777 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29526,17 +36798,17 @@ module Tables = struct let _startpos = _startpos_d_ in let _endpos = _endpos_d_ in let _v : (Parsetree.constructor_declaration list) = let x = -# 3263 "src/ocaml/preprocess/parser_raw.mly" +# 3403 "src/ocaml/preprocess/parser_raw.mly" ( let cid, vars, args, res, attrs, loc, info = d in Type.constructor cid ~vars ~args ?res ~attrs ~loc ~info ) -# 29535 "src/ocaml/preprocess/parser_raw.ml" +# 36807 "src/ocaml/preprocess/parser_raw.ml" in -# 1202 "src/ocaml/preprocess/parser_raw.mly" +# 1260 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 29540 "src/ocaml/preprocess/parser_raw.ml" +# 36812 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29561,17 +36833,17 @@ module Tables = struct let _startpos = _startpos_d_ in let _endpos = _endpos_d_ in let _v : (Parsetree.constructor_declaration list) = let x = -# 3263 "src/ocaml/preprocess/parser_raw.mly" +# 3403 "src/ocaml/preprocess/parser_raw.mly" ( let cid, vars, args, res, attrs, loc, info = d in Type.constructor cid ~vars ~args ?res ~attrs ~loc ~info ) -# 29570 "src/ocaml/preprocess/parser_raw.ml" +# 36842 "src/ocaml/preprocess/parser_raw.ml" in -# 1205 "src/ocaml/preprocess/parser_raw.mly" +# 1263 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 29575 "src/ocaml/preprocess/parser_raw.ml" +# 36847 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29603,17 +36875,17 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_d_ in let _v : (Parsetree.constructor_declaration list) = let x = -# 3263 "src/ocaml/preprocess/parser_raw.mly" +# 3403 "src/ocaml/preprocess/parser_raw.mly" ( let cid, vars, args, res, attrs, loc, info = d in Type.constructor cid ~vars ~args ?res ~attrs ~loc ~info ) -# 29612 "src/ocaml/preprocess/parser_raw.ml" +# 36884 "src/ocaml/preprocess/parser_raw.ml" in -# 1209 "src/ocaml/preprocess/parser_raw.mly" +# 1267 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 29617 "src/ocaml/preprocess/parser_raw.ml" +# 36889 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29639,23 +36911,23 @@ module Tables = struct let _endpos = _endpos_d_ in let _v : (Parsetree.extension_constructor list) = let x = let _1 = -# 3380 "src/ocaml/preprocess/parser_raw.mly" +# 3520 "src/ocaml/preprocess/parser_raw.mly" ( let cid, vars, args, res, attrs, loc, info = d in Te.decl cid ~vars ~args ?res ~attrs ~loc ~info ) -# 29648 "src/ocaml/preprocess/parser_raw.ml" +# 36920 "src/ocaml/preprocess/parser_raw.ml" in -# 3374 "src/ocaml/preprocess/parser_raw.mly" +# 3514 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 29653 "src/ocaml/preprocess/parser_raw.ml" +# 36925 "src/ocaml/preprocess/parser_raw.ml" in -# 1202 "src/ocaml/preprocess/parser_raw.mly" +# 1260 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 29659 "src/ocaml/preprocess/parser_raw.ml" +# 36931 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29678,14 +36950,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.extension_constructor list) = let x = -# 3376 "src/ocaml/preprocess/parser_raw.mly" +# 3516 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 29684 "src/ocaml/preprocess/parser_raw.ml" +# 36956 "src/ocaml/preprocess/parser_raw.ml" in -# 1202 "src/ocaml/preprocess/parser_raw.mly" +# 1260 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 29689 "src/ocaml/preprocess/parser_raw.ml" +# 36961 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29711,23 +36983,23 @@ module Tables = struct let _endpos = _endpos_d_ in let _v : (Parsetree.extension_constructor list) = let x = let _1 = -# 3380 "src/ocaml/preprocess/parser_raw.mly" +# 3520 "src/ocaml/preprocess/parser_raw.mly" ( let cid, vars, args, res, attrs, loc, info = d in Te.decl cid ~vars ~args ?res ~attrs ~loc ~info ) -# 29720 "src/ocaml/preprocess/parser_raw.ml" +# 36992 "src/ocaml/preprocess/parser_raw.ml" in -# 3374 "src/ocaml/preprocess/parser_raw.mly" +# 3514 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 29725 "src/ocaml/preprocess/parser_raw.ml" +# 36997 "src/ocaml/preprocess/parser_raw.ml" in -# 1205 "src/ocaml/preprocess/parser_raw.mly" +# 1263 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 29731 "src/ocaml/preprocess/parser_raw.ml" +# 37003 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29750,14 +37022,14 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.extension_constructor list) = let x = -# 3376 "src/ocaml/preprocess/parser_raw.mly" +# 3516 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 29756 "src/ocaml/preprocess/parser_raw.ml" +# 37028 "src/ocaml/preprocess/parser_raw.ml" in -# 1205 "src/ocaml/preprocess/parser_raw.mly" +# 1263 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 29761 "src/ocaml/preprocess/parser_raw.ml" +# 37033 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29790,23 +37062,23 @@ module Tables = struct let _endpos = _endpos_d_ in let _v : (Parsetree.extension_constructor list) = let x = let _1 = -# 3380 "src/ocaml/preprocess/parser_raw.mly" +# 3520 "src/ocaml/preprocess/parser_raw.mly" ( let cid, vars, args, res, attrs, loc, info = d in Te.decl cid ~vars ~args ?res ~attrs ~loc ~info ) -# 29799 "src/ocaml/preprocess/parser_raw.ml" +# 37071 "src/ocaml/preprocess/parser_raw.ml" in -# 3374 "src/ocaml/preprocess/parser_raw.mly" +# 3514 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 29804 "src/ocaml/preprocess/parser_raw.ml" +# 37076 "src/ocaml/preprocess/parser_raw.ml" in -# 1209 "src/ocaml/preprocess/parser_raw.mly" +# 1267 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 29810 "src/ocaml/preprocess/parser_raw.ml" +# 37082 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29836,14 +37108,14 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos__1_ in let _v : (Parsetree.extension_constructor list) = let x = -# 3376 "src/ocaml/preprocess/parser_raw.mly" +# 3516 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 29842 "src/ocaml/preprocess/parser_raw.ml" +# 37114 "src/ocaml/preprocess/parser_raw.ml" in -# 1209 "src/ocaml/preprocess/parser_raw.mly" +# 1267 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 29847 "src/ocaml/preprocess/parser_raw.ml" +# 37119 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29868,17 +37140,17 @@ module Tables = struct let _startpos = _startpos_d_ in let _endpos = _endpos_d_ in let _v : (Parsetree.extension_constructor list) = let x = -# 3380 "src/ocaml/preprocess/parser_raw.mly" +# 3520 "src/ocaml/preprocess/parser_raw.mly" ( let cid, vars, args, res, attrs, loc, info = d in Te.decl cid ~vars ~args ?res ~attrs ~loc ~info ) -# 29877 "src/ocaml/preprocess/parser_raw.ml" +# 37149 "src/ocaml/preprocess/parser_raw.ml" in -# 1202 "src/ocaml/preprocess/parser_raw.mly" +# 1260 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 29882 "src/ocaml/preprocess/parser_raw.ml" +# 37154 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29903,17 +37175,17 @@ module Tables = struct let _startpos = _startpos_d_ in let _endpos = _endpos_d_ in let _v : (Parsetree.extension_constructor list) = let x = -# 3380 "src/ocaml/preprocess/parser_raw.mly" +# 3520 "src/ocaml/preprocess/parser_raw.mly" ( let cid, vars, args, res, attrs, loc, info = d in Te.decl cid ~vars ~args ?res ~attrs ~loc ~info ) -# 29912 "src/ocaml/preprocess/parser_raw.ml" +# 37184 "src/ocaml/preprocess/parser_raw.ml" in -# 1205 "src/ocaml/preprocess/parser_raw.mly" +# 1263 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 29917 "src/ocaml/preprocess/parser_raw.ml" +# 37189 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29945,17 +37217,17 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_d_ in let _v : (Parsetree.extension_constructor list) = let x = -# 3380 "src/ocaml/preprocess/parser_raw.mly" +# 3520 "src/ocaml/preprocess/parser_raw.mly" ( let cid, vars, args, res, attrs, loc, info = d in Te.decl cid ~vars ~args ?res ~attrs ~loc ~info ) -# 29954 "src/ocaml/preprocess/parser_raw.ml" +# 37226 "src/ocaml/preprocess/parser_raw.ml" in -# 1209 "src/ocaml/preprocess/parser_raw.mly" +# 1267 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 29959 "src/ocaml/preprocess/parser_raw.ml" +# 37231 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -29971,9 +37243,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : ((Parsetree.core_type * Parsetree.core_type * Location.t) list) = -# 1068 "src/ocaml/preprocess/parser_raw.mly" +# 1105 "src/ocaml/preprocess/parser_raw.mly" ( [] ) -# 29977 "src/ocaml/preprocess/parser_raw.ml" +# 37249 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30030,21 +37302,78 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2224 "src/ocaml/preprocess/parser_raw.mly" +# 2299 "src/ocaml/preprocess/parser_raw.mly" ( _1, _3, make_loc _sloc ) -# 30036 "src/ocaml/preprocess/parser_raw.ml" +# 37308 "src/ocaml/preprocess/parser_raw.ml" in # 183 "" ( x ) -# 30042 "src/ocaml/preprocess/parser_raw.ml" +# 37314 "src/ocaml/preprocess/parser_raw.ml" in -# 1070 "src/ocaml/preprocess/parser_raw.mly" +# 1107 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 30048 "src/ocaml/preprocess/parser_raw.ml" +# 37320 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = x; + MenhirLib.EngineTypes.startp = _startpos_x_; + MenhirLib.EngineTypes.endp = _endpos_x_; + MenhirLib.EngineTypes.next = _menhir_stack; + } = _menhir_stack in + let x : (Parsetree.function_param list) = Obj.magic x in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_x_ in + let _endpos = _endpos_x_ in + let _v : (Parsetree.function_param list) = +# 1138 "src/ocaml/preprocess/parser_raw.mly" + ( List.rev x ) +# 37345 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = x; + MenhirLib.EngineTypes.startp = _startpos_x_; + MenhirLib.EngineTypes.endp = _endpos_x_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + } = _menhir_stack in + let x : (Parsetree.function_param list) = Obj.magic x in + let xs : (Parsetree.function_param list) = Obj.magic xs in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_xs_ in + let _endpos = _endpos_x_ in + let _v : (Parsetree.function_param list) = +# 1140 "src/ocaml/preprocess/parser_raw.mly" + ( List.rev_append x xs ) +# 37377 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30067,9 +37396,9 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : ((Lexing.position * Parsetree.functor_parameter) list) = -# 1082 "src/ocaml/preprocess/parser_raw.mly" +# 1119 "src/ocaml/preprocess/parser_raw.mly" ( [ x ] ) -# 30073 "src/ocaml/preprocess/parser_raw.ml" +# 37402 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30099,9 +37428,9 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : ((Lexing.position * Parsetree.functor_parameter) list) = -# 1084 "src/ocaml/preprocess/parser_raw.mly" +# 1121 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 30105 "src/ocaml/preprocess/parser_raw.ml" +# 37434 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30124,9 +37453,9 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : ((Asttypes.arg_label * Parsetree.expression) list) = -# 1082 "src/ocaml/preprocess/parser_raw.mly" +# 1119 "src/ocaml/preprocess/parser_raw.mly" ( [ x ] ) -# 30130 "src/ocaml/preprocess/parser_raw.ml" +# 37459 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30156,9 +37485,9 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : ((Asttypes.arg_label * Parsetree.expression) list) = -# 1084 "src/ocaml/preprocess/parser_raw.mly" +# 1121 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 30162 "src/ocaml/preprocess/parser_raw.ml" +# 37491 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30181,9 +37510,9 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (string list) = -# 1082 "src/ocaml/preprocess/parser_raw.mly" +# 1119 "src/ocaml/preprocess/parser_raw.mly" ( [ x ] ) -# 30187 "src/ocaml/preprocess/parser_raw.ml" +# 37516 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30213,9 +37542,9 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (string list) = -# 1084 "src/ocaml/preprocess/parser_raw.mly" +# 1121 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 30219 "src/ocaml/preprocess/parser_raw.ml" +# 37548 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30228,9 +37557,9 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _menhir_s; MenhirLib.EngineTypes.semv = _1; @@ -30239,33 +37568,25 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; }; } = _menhir_stack in - let _1_inlined1 : (string) = Obj.magic _1_inlined1 in + let _2 : (string) = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__1_inlined1_ in + let _endpos = _endpos__2_ in let _v : (string Location.loc list) = let x = - let _2 = - let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 990 "src/ocaml/preprocess/parser_raw.mly" - ( mkrhs _1 _sloc ) -# 30257 "src/ocaml/preprocess/parser_raw.ml" - - in + let _endpos = _endpos__2_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 3438 "src/ocaml/preprocess/parser_raw.mly" - ( _2 ) -# 30263 "src/ocaml/preprocess/parser_raw.ml" +# 3578 "src/ocaml/preprocess/parser_raw.mly" + ( mkrhs _2 _sloc ) +# 37584 "src/ocaml/preprocess/parser_raw.ml" in -# 1082 "src/ocaml/preprocess/parser_raw.mly" +# 1119 "src/ocaml/preprocess/parser_raw.mly" ( [ x ] ) -# 30269 "src/ocaml/preprocess/parser_raw.ml" +# 37590 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30278,9 +37599,9 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _1_inlined1; - MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; - MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _1; @@ -30295,34 +37616,26 @@ module Tables = struct }; }; } = _menhir_stack in - let _1_inlined1 : (string) = Obj.magic _1_inlined1 in + let _2 : (string) = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let xs : (string Location.loc list) = Obj.magic xs in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos_xs_ in - let _endpos = _endpos__1_inlined1_ in + let _endpos = _endpos__2_ in let _v : (string Location.loc list) = let x = - let _2 = - let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 990 "src/ocaml/preprocess/parser_raw.mly" - ( mkrhs _1 _sloc ) -# 30314 "src/ocaml/preprocess/parser_raw.ml" - - in + let _endpos = _endpos__2_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 3438 "src/ocaml/preprocess/parser_raw.mly" - ( _2 ) -# 30320 "src/ocaml/preprocess/parser_raw.ml" +# 3578 "src/ocaml/preprocess/parser_raw.mly" + ( mkrhs _2 _sloc ) +# 37633 "src/ocaml/preprocess/parser_raw.ml" in -# 1084 "src/ocaml/preprocess/parser_raw.mly" +# 1121 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 30326 "src/ocaml/preprocess/parser_raw.ml" +# 37639 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30347,12 +37660,12 @@ module Tables = struct let _v : (Parsetree.case list) = let _1 = # 124 "" ( None ) -# 30351 "src/ocaml/preprocess/parser_raw.ml" +# 37664 "src/ocaml/preprocess/parser_raw.ml" in -# 1173 "src/ocaml/preprocess/parser_raw.mly" +# 1231 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 30356 "src/ocaml/preprocess/parser_raw.ml" +# 37669 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30386,13 +37699,13 @@ module Tables = struct # 126 "" ( Some x ) -# 30390 "src/ocaml/preprocess/parser_raw.ml" +# 37703 "src/ocaml/preprocess/parser_raw.ml" in -# 1173 "src/ocaml/preprocess/parser_raw.mly" +# 1231 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 30396 "src/ocaml/preprocess/parser_raw.ml" +# 37709 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30429,9 +37742,9 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Parsetree.case list) = -# 1177 "src/ocaml/preprocess/parser_raw.mly" +# 1235 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 30435 "src/ocaml/preprocess/parser_raw.ml" +# 37748 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30455,20 +37768,20 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.core_type list) = let xs = let x = -# 3481 "src/ocaml/preprocess/parser_raw.mly" +# 3621 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 30461 "src/ocaml/preprocess/parser_raw.ml" +# 37774 "src/ocaml/preprocess/parser_raw.ml" in -# 1108 "src/ocaml/preprocess/parser_raw.mly" +# 1166 "src/ocaml/preprocess/parser_raw.mly" ( [ x ] ) -# 30466 "src/ocaml/preprocess/parser_raw.ml" +# 37779 "src/ocaml/preprocess/parser_raw.ml" in -# 1116 "src/ocaml/preprocess/parser_raw.mly" +# 1174 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 30472 "src/ocaml/preprocess/parser_raw.ml" +# 37785 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30506,20 +37819,20 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.core_type list) = let xs = let x = -# 3481 "src/ocaml/preprocess/parser_raw.mly" +# 3621 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 30512 "src/ocaml/preprocess/parser_raw.ml" +# 37825 "src/ocaml/preprocess/parser_raw.ml" in -# 1112 "src/ocaml/preprocess/parser_raw.mly" +# 1170 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 30517 "src/ocaml/preprocess/parser_raw.ml" +# 37830 "src/ocaml/preprocess/parser_raw.ml" in -# 1116 "src/ocaml/preprocess/parser_raw.mly" +# 1174 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 30523 "src/ocaml/preprocess/parser_raw.ml" +# 37836 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30542,14 +37855,14 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (Parsetree.with_constraint list) = let xs = -# 1108 "src/ocaml/preprocess/parser_raw.mly" +# 1166 "src/ocaml/preprocess/parser_raw.mly" ( [ x ] ) -# 30548 "src/ocaml/preprocess/parser_raw.ml" +# 37861 "src/ocaml/preprocess/parser_raw.ml" in -# 1116 "src/ocaml/preprocess/parser_raw.mly" +# 1174 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 30553 "src/ocaml/preprocess/parser_raw.ml" +# 37866 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30586,14 +37899,14 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Parsetree.with_constraint list) = let xs = -# 1112 "src/ocaml/preprocess/parser_raw.mly" +# 1170 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 30592 "src/ocaml/preprocess/parser_raw.ml" +# 37905 "src/ocaml/preprocess/parser_raw.ml" in -# 1116 "src/ocaml/preprocess/parser_raw.mly" +# 1174 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 30597 "src/ocaml/preprocess/parser_raw.ml" +# 37910 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30616,14 +37929,14 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (Parsetree.row_field list) = let xs = -# 1108 "src/ocaml/preprocess/parser_raw.mly" +# 1166 "src/ocaml/preprocess/parser_raw.mly" ( [ x ] ) -# 30622 "src/ocaml/preprocess/parser_raw.ml" +# 37935 "src/ocaml/preprocess/parser_raw.ml" in -# 1116 "src/ocaml/preprocess/parser_raw.mly" +# 1174 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 30627 "src/ocaml/preprocess/parser_raw.ml" +# 37940 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30660,14 +37973,14 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Parsetree.row_field list) = let xs = -# 1112 "src/ocaml/preprocess/parser_raw.mly" +# 1170 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 30666 "src/ocaml/preprocess/parser_raw.ml" +# 37979 "src/ocaml/preprocess/parser_raw.ml" in -# 1116 "src/ocaml/preprocess/parser_raw.mly" +# 1174 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 30671 "src/ocaml/preprocess/parser_raw.ml" +# 37984 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30690,14 +38003,14 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (Parsetree.core_type list) = let xs = -# 1108 "src/ocaml/preprocess/parser_raw.mly" +# 1166 "src/ocaml/preprocess/parser_raw.mly" ( [ x ] ) -# 30696 "src/ocaml/preprocess/parser_raw.ml" +# 38009 "src/ocaml/preprocess/parser_raw.ml" in -# 1116 "src/ocaml/preprocess/parser_raw.mly" +# 1174 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 30701 "src/ocaml/preprocess/parser_raw.ml" +# 38014 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30734,14 +38047,14 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Parsetree.core_type list) = let xs = -# 1112 "src/ocaml/preprocess/parser_raw.mly" +# 1170 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 30740 "src/ocaml/preprocess/parser_raw.ml" +# 38053 "src/ocaml/preprocess/parser_raw.ml" in -# 1116 "src/ocaml/preprocess/parser_raw.mly" +# 1174 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 30745 "src/ocaml/preprocess/parser_raw.ml" +# 38058 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30764,14 +38077,14 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = let xs = -# 1108 "src/ocaml/preprocess/parser_raw.mly" +# 1166 "src/ocaml/preprocess/parser_raw.mly" ( [ x ] ) -# 30770 "src/ocaml/preprocess/parser_raw.ml" +# 38083 "src/ocaml/preprocess/parser_raw.ml" in -# 1116 "src/ocaml/preprocess/parser_raw.mly" +# 1174 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 30775 "src/ocaml/preprocess/parser_raw.ml" +# 38088 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30808,14 +38121,14 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = let xs = -# 1112 "src/ocaml/preprocess/parser_raw.mly" +# 1170 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 30814 "src/ocaml/preprocess/parser_raw.ml" +# 38127 "src/ocaml/preprocess/parser_raw.ml" in -# 1116 "src/ocaml/preprocess/parser_raw.mly" +# 1174 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 30819 "src/ocaml/preprocess/parser_raw.ml" +# 38132 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30838,14 +38151,14 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_x_ in let _v : (Parsetree.core_type list) = let xs = -# 1108 "src/ocaml/preprocess/parser_raw.mly" +# 1166 "src/ocaml/preprocess/parser_raw.mly" ( [ x ] ) -# 30844 "src/ocaml/preprocess/parser_raw.ml" +# 38157 "src/ocaml/preprocess/parser_raw.ml" in -# 1116 "src/ocaml/preprocess/parser_raw.mly" +# 1174 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 30849 "src/ocaml/preprocess/parser_raw.ml" +# 38162 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30882,14 +38195,14 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Parsetree.core_type list) = let xs = -# 1112 "src/ocaml/preprocess/parser_raw.mly" +# 1170 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 30888 "src/ocaml/preprocess/parser_raw.ml" +# 38201 "src/ocaml/preprocess/parser_raw.ml" in -# 1116 "src/ocaml/preprocess/parser_raw.mly" +# 1174 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 30893 "src/ocaml/preprocess/parser_raw.ml" +# 38206 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30926,9 +38239,9 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Parsetree.core_type list) = -# 1139 "src/ocaml/preprocess/parser_raw.mly" +# 1197 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 30932 "src/ocaml/preprocess/parser_raw.ml" +# 38245 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30965,9 +38278,386 @@ module Tables = struct let _startpos = _startpos_x1_ in let _endpos = _endpos_x2_ in let _v : (Parsetree.core_type list) = -# 1143 "src/ocaml/preprocess/parser_raw.mly" +# 1201 "src/ocaml/preprocess/parser_raw.mly" + ( [ x2; x1 ] ) +# 38284 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1 : (Parsetree.expression) = Obj.magic _1 in + let _2 : unit = Obj.magic _2 in + let xs : (Parsetree.expression list) = Obj.magic xs in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_xs_ in + let _endpos = _endpos__1_ in + let _v : (Parsetree.expression list) = let x = + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38324 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38329 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 1197 "src/ocaml/preprocess/parser_raw.mly" + ( x :: xs ) +# 38335 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs_inlined1; + MenhirLib.EngineTypes.startp = _startpos_xs_inlined1_; + MenhirLib.EngineTypes.endp = _endpos_xs_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs_inlined1 : (Parsetree.case list) = Obj.magic xs_inlined1 in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _2 : unit = Obj.magic _2 in + let xs : (Parsetree.expression list) = Obj.magic xs in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos_xs_ in + let _endpos = _endpos_xs_inlined1_ in + let _v : (Parsetree.expression list) = let x = + let (_endpos_xs_, xs) = (_endpos_xs_inlined1_, xs_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 38400 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 38405 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 38411 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38422 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 38428 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 38448 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38454 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 1197 "src/ocaml/preprocess/parser_raw.mly" + ( x :: xs ) +# 38460 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in + let _1 : (Parsetree.expression) = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_inlined1_ in + let _v : (Parsetree.expression list) = let x2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38501 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38506 "src/ocaml/preprocess/parser_raw.ml" + + in + let x1 = + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38513 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38518 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 1201 "src/ocaml/preprocess/parser_raw.mly" + ( [ x2; x1 ] ) +# 38524 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in + let _2 : unit = Obj.magic _2 in + let _1 : (Parsetree.expression) = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression list) = let x2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 38589 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 38594 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 38600 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38611 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 38617 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 38637 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38643 "src/ocaml/preprocess/parser_raw.ml" + + in + let x1 = + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38650 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38655 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 1201 "src/ocaml/preprocess/parser_raw.mly" ( [ x2; x1 ] ) -# 30971 "src/ocaml/preprocess/parser_raw.ml" +# 38661 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -30980,33 +38670,131 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = x; - MenhirLib.EngineTypes.startp = _startpos_x_; - MenhirLib.EngineTypes.endp = _endpos_x_; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = _2; MenhirLib.EngineTypes.startp = _startpos__2_; MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.state = _; MenhirLib.EngineTypes.semv = xs; MenhirLib.EngineTypes.startp = _startpos_xs_; MenhirLib.EngineTypes.endp = _endpos_xs_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; }; }; } = _menhir_stack in - let x : (Parsetree.expression) = Obj.magic x in + let _1_inlined3 : (Parsetree.expression) = Obj.magic _1_inlined3 in let _2 : unit = Obj.magic _2 in - let xs : (Parsetree.expression list) = Obj.magic xs in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_xs_ in - let _endpos = _endpos_x_ in - let _v : (Parsetree.expression list) = -# 1139 "src/ocaml/preprocess/parser_raw.mly" - ( x :: xs ) -# 31010 "src/ocaml/preprocess/parser_raw.ml" + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_inlined3_ in + let _v : (Parsetree.expression list) = let x2 = + let _1 = _1_inlined3 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38723 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38728 "src/ocaml/preprocess/parser_raw.ml" + + in + let x1 = + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 38738 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 38743 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 38749 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38760 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 38766 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 38786 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38792 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 1201 "src/ocaml/preprocess/parser_raw.mly" + ( [ x2; x1 ] ) +# 38798 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31019,33 +38807,204 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = x2; - MenhirLib.EngineTypes.startp = _startpos_x2_; - MenhirLib.EngineTypes.endp = _endpos_x2_; + MenhirLib.EngineTypes.semv = xs_inlined1; + MenhirLib.EngineTypes.startp = _startpos_xs_inlined1_; + MenhirLib.EngineTypes.endp = _endpos_xs_inlined1_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.semv = _1_inlined5; + MenhirLib.EngineTypes.startp = _startpos__1_inlined5_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined5_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = x1; - MenhirLib.EngineTypes.startp = _startpos_x1_; - MenhirLib.EngineTypes.endp = _endpos_x1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined4; + MenhirLib.EngineTypes.startp = _startpos__1_inlined4_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + }; + }; }; }; } = _menhir_stack in - let x2 : (Parsetree.expression) = Obj.magic x2 in + let xs_inlined1 : (Parsetree.case list) = Obj.magic xs_inlined1 in + let _1_inlined5 : (Parsetree.attributes) = Obj.magic _1_inlined5 in + let _1_inlined4 : (string Location.loc option) = Obj.magic _1_inlined4 in + let _1_inlined3 : unit = Obj.magic _1_inlined3 in let _2 : unit = Obj.magic _2 in - let x1 : (Parsetree.expression) = Obj.magic x1 in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_x1_ in - let _endpos = _endpos_x2_ in - let _v : (Parsetree.expression list) = -# 1143 "src/ocaml/preprocess/parser_raw.mly" + let _startpos = _startpos__1_ in + let _endpos = _endpos_xs_inlined1_ in + let _v : (Parsetree.expression list) = let x2 = + let (_endpos_xs_, _startpos__1_, xs, _1_inlined2, _1_inlined1, _1) = (_endpos_xs_inlined1_, _startpos__1_inlined3_, xs_inlined1, _1_inlined5, _1_inlined4, _1_inlined3) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 38884 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 38889 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 38895 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38906 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 38912 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 38932 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38938 "src/ocaml/preprocess/parser_raw.ml" + + in + let x1 = + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 38948 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 38953 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 38959 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 38970 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 38976 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 38996 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 39002 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 1201 "src/ocaml/preprocess/parser_raw.mly" ( [ x2; x1 ] ) -# 31049 "src/ocaml/preprocess/parser_raw.ml" +# 39008 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31082,9 +39041,9 @@ module Tables = struct let _startpos = _startpos_xs_ in let _endpos = _endpos_x_ in let _v : (Parsetree.core_type list) = -# 1139 "src/ocaml/preprocess/parser_raw.mly" +# 1197 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 31088 "src/ocaml/preprocess/parser_raw.ml" +# 39047 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31121,9 +39080,9 @@ module Tables = struct let _startpos = _startpos_x1_ in let _endpos = _endpos_x2_ in let _v : (Parsetree.core_type list) = -# 1143 "src/ocaml/preprocess/parser_raw.mly" +# 1201 "src/ocaml/preprocess/parser_raw.mly" ( [ x2; x1 ] ) -# 31127 "src/ocaml/preprocess/parser_raw.ml" +# 39086 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31146,9 +39105,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.row_field) = -# 3621 "src/ocaml/preprocess/parser_raw.mly" +# 3817 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 31152 "src/ocaml/preprocess/parser_raw.ml" +# 39111 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31174,9 +39133,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3623 "src/ocaml/preprocess/parser_raw.mly" +# 3819 "src/ocaml/preprocess/parser_raw.mly" ( Rf.inherit_ ~loc:(make_loc _sloc) _1 ) -# 31180 "src/ocaml/preprocess/parser_raw.ml" +# 39139 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31189,24 +39148,36 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = x; - MenhirLib.EngineTypes.startp = _startpos_x_; - MenhirLib.EngineTypes.endp = _endpos_x_; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in - let x : (Parsetree.expression) = Obj.magic x in + let _1 : (Parsetree.expression) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_x_ in - let _endpos = _endpos_x_ in + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_ in let _v : (Parsetree.expression list) = let _2 = # 124 "" ( None ) -# 31205 "src/ocaml/preprocess/parser_raw.ml" +# 39164 "src/ocaml/preprocess/parser_raw.ml" in + let x = + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 39170 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 39175 "src/ocaml/preprocess/parser_raw.ml" + + in -# 1160 "src/ocaml/preprocess/parser_raw.mly" +# 1218 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 31210 "src/ocaml/preprocess/parser_raw.ml" +# 39181 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31219,34 +39190,331 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = x_inlined1; - MenhirLib.EngineTypes.startp = _startpos_x_inlined1_; - MenhirLib.EngineTypes.endp = _endpos_x_inlined1_; + MenhirLib.EngineTypes.semv = x; + MenhirLib.EngineTypes.startp = _startpos_x_; + MenhirLib.EngineTypes.endp = _endpos_x_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = x; - MenhirLib.EngineTypes.startp = _startpos_x_; - MenhirLib.EngineTypes.endp = _endpos_x_; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; MenhirLib.EngineTypes.next = _menhir_stack; }; } = _menhir_stack in - let x_inlined1 : unit = Obj.magic x_inlined1 in - let x : (Parsetree.expression) = Obj.magic x in + let x : unit = Obj.magic x in + let _1 : (Parsetree.expression) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_x_ in - let _endpos = _endpos_x_inlined1_ in - let _v : (Parsetree.expression list) = let _2 = - let x = x_inlined1 in + let _startpos = _startpos__1_ in + let _endpos = _endpos_x_ in + let _v : (Parsetree.expression list) = let _2 = +# 126 "" + ( Some x ) +# 39213 "src/ocaml/preprocess/parser_raw.ml" + in + let x = + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 39219 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 39224 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 1218 "src/ocaml/preprocess/parser_raw.mly" + ( [x] ) +# 39230 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression list) = let _2 = +# 124 "" + ( None ) +# 39276 "src/ocaml/preprocess/parser_raw.ml" + in + let x = + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 39285 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 39290 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 39296 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 39307 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 39313 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 39333 "src/ocaml/preprocess/parser_raw.ml" + + in +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 39339 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 1218 "src/ocaml/preprocess/parser_raw.mly" + ( [x] ) +# 39345 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = x; + MenhirLib.EngineTypes.startp = _startpos_x_; + MenhirLib.EngineTypes.endp = _endpos_x_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + } = _menhir_stack in + let x : unit = Obj.magic x in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos_x_ in + let _v : (Parsetree.expression list) = let _2 = # 126 "" ( Some x ) -# 31244 "src/ocaml/preprocess/parser_raw.ml" +# 39398 "src/ocaml/preprocess/parser_raw.ml" + in + let x = + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 39407 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 39412 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 39418 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 39429 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 39435 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 39455 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 39461 "src/ocaml/preprocess/parser_raw.ml" in -# 1160 "src/ocaml/preprocess/parser_raw.mly" +# 1218 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 31250 "src/ocaml/preprocess/parser_raw.ml" +# 39467 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let xs : (Parsetree.expression list) = Obj.magic xs in + let _2 : unit = Obj.magic _2 in + let _1 : (Parsetree.expression) = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos_xs_ in + let _v : (Parsetree.expression list) = let x = + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 39507 "src/ocaml/preprocess/parser_raw.ml" + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 39512 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 1222 "src/ocaml/preprocess/parser_raw.mly" + ( x :: xs ) +# 39518 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31268,24 +39536,110 @@ module Tables = struct MenhirLib.EngineTypes.startp = _startpos__2_; MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = x; - MenhirLib.EngineTypes.startp = _startpos_x_; - MenhirLib.EngineTypes.endp = _endpos_x_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = xs_inlined1; + MenhirLib.EngineTypes.startp = _startpos_xs_inlined1_; + MenhirLib.EngineTypes.endp = _endpos_xs_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; }; }; } = _menhir_stack in let xs : (Parsetree.expression list) = Obj.magic xs in let _2 : unit = Obj.magic _2 in - let x : (Parsetree.expression) = Obj.magic x in + let xs_inlined1 : (Parsetree.case list) = Obj.magic xs_inlined1 in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos_x_ in + let _startpos = _startpos__1_ in let _endpos = _endpos_xs_ in - let _v : (Parsetree.expression list) = -# 1164 "src/ocaml/preprocess/parser_raw.mly" + let _v : (Parsetree.expression list) = let x = + let (_endpos_xs_, xs) = (_endpos_xs_inlined1_, xs_inlined1) in + let _1 = + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 39583 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 39588 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 39594 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 39605 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 39611 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 39631 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 39637 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 1222 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 31289 "src/ocaml/preprocess/parser_raw.ml" +# 39643 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31311,9 +39665,9 @@ module Tables = struct } = _menhir_stack in let oe : (Parsetree.expression option) = Obj.magic oe in let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 31317 "src/ocaml/preprocess/parser_raw.ml" +# 39671 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -31321,26 +39675,26 @@ module Tables = struct let _v : ((string Location.loc * Parsetree.expression) list) = let _2 = # 124 "" ( None ) -# 31325 "src/ocaml/preprocess/parser_raw.ml" +# 39679 "src/ocaml/preprocess/parser_raw.ml" in let x = let label = let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 31332 "src/ocaml/preprocess/parser_raw.ml" +# 39686 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 31340 "src/ocaml/preprocess/parser_raw.ml" +# 39694 "src/ocaml/preprocess/parser_raw.ml" in -# 2834 "src/ocaml/preprocess/parser_raw.mly" +# 2974 "src/ocaml/preprocess/parser_raw.mly" ( let label, e = match oe with | None -> @@ -31350,13 +39704,13 @@ module Tables = struct label, e in label, e ) -# 31354 "src/ocaml/preprocess/parser_raw.ml" +# 39708 "src/ocaml/preprocess/parser_raw.ml" in -# 1160 "src/ocaml/preprocess/parser_raw.mly" +# 1218 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 31360 "src/ocaml/preprocess/parser_raw.ml" +# 39714 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31389,9 +39743,9 @@ module Tables = struct let x : unit = Obj.magic x in let oe : (Parsetree.expression option) = Obj.magic oe in let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 31395 "src/ocaml/preprocess/parser_raw.ml" +# 39749 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -31399,26 +39753,26 @@ module Tables = struct let _v : ((string Location.loc * Parsetree.expression) list) = let _2 = # 126 "" ( Some x ) -# 31403 "src/ocaml/preprocess/parser_raw.ml" +# 39757 "src/ocaml/preprocess/parser_raw.ml" in let x = let label = let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 31410 "src/ocaml/preprocess/parser_raw.ml" +# 39764 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 31418 "src/ocaml/preprocess/parser_raw.ml" +# 39772 "src/ocaml/preprocess/parser_raw.ml" in -# 2834 "src/ocaml/preprocess/parser_raw.mly" +# 2974 "src/ocaml/preprocess/parser_raw.mly" ( let label, e = match oe with | None -> @@ -31428,13 +39782,13 @@ module Tables = struct label, e in label, e ) -# 31432 "src/ocaml/preprocess/parser_raw.ml" +# 39786 "src/ocaml/preprocess/parser_raw.ml" in -# 1160 "src/ocaml/preprocess/parser_raw.mly" +# 1218 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 31438 "src/ocaml/preprocess/parser_raw.ml" +# 39792 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31474,9 +39828,9 @@ module Tables = struct let _2 : unit = Obj.magic _2 in let oe : (Parsetree.expression option) = Obj.magic oe in let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 31480 "src/ocaml/preprocess/parser_raw.ml" +# 39834 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -31484,21 +39838,21 @@ module Tables = struct let _v : ((string Location.loc * Parsetree.expression) list) = let x = let label = let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 31490 "src/ocaml/preprocess/parser_raw.ml" +# 39844 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 31498 "src/ocaml/preprocess/parser_raw.ml" +# 39852 "src/ocaml/preprocess/parser_raw.ml" in -# 2834 "src/ocaml/preprocess/parser_raw.mly" +# 2974 "src/ocaml/preprocess/parser_raw.mly" ( let label, e = match oe with | None -> @@ -31508,13 +39862,13 @@ module Tables = struct label, e in label, e ) -# 31512 "src/ocaml/preprocess/parser_raw.ml" +# 39866 "src/ocaml/preprocess/parser_raw.ml" in -# 1164 "src/ocaml/preprocess/parser_raw.mly" +# 1222 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 31518 "src/ocaml/preprocess/parser_raw.ml" +# 39872 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31539,12 +39893,12 @@ module Tables = struct let _v : (Parsetree.pattern list) = let _2 = # 124 "" ( None ) -# 31543 "src/ocaml/preprocess/parser_raw.ml" +# 39897 "src/ocaml/preprocess/parser_raw.ml" in -# 1160 "src/ocaml/preprocess/parser_raw.mly" +# 1218 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 31548 "src/ocaml/preprocess/parser_raw.ml" +# 39902 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31578,13 +39932,13 @@ module Tables = struct # 126 "" ( Some x ) -# 31582 "src/ocaml/preprocess/parser_raw.ml" +# 39936 "src/ocaml/preprocess/parser_raw.ml" in -# 1160 "src/ocaml/preprocess/parser_raw.mly" +# 1218 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 31588 "src/ocaml/preprocess/parser_raw.ml" +# 39942 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31621,9 +39975,9 @@ module Tables = struct let _startpos = _startpos_x_ in let _endpos = _endpos_xs_ in let _v : (Parsetree.pattern list) = -# 1164 "src/ocaml/preprocess/parser_raw.mly" +# 1222 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 31627 "src/ocaml/preprocess/parser_raw.ml" +# 39981 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31654,7 +40008,7 @@ module Tables = struct }; } = _menhir_stack in let eo : (Parsetree.expression option) = Obj.magic eo in - let c : ((Parsetree.core_type option * Parsetree.core_type option) option) = Obj.magic c in + let c : (Parsetree.type_constraint option) = Obj.magic c in let _1 : (Longident.t) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -31662,7 +40016,7 @@ module Tables = struct let _v : ((Longident.t Location.loc * Parsetree.expression) list) = let _2 = # 124 "" ( None ) -# 31666 "src/ocaml/preprocess/parser_raw.ml" +# 40020 "src/ocaml/preprocess/parser_raw.ml" in let x = let label = @@ -31670,9 +40024,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 31676 "src/ocaml/preprocess/parser_raw.ml" +# 40030 "src/ocaml/preprocess/parser_raw.ml" in let _startpos_label_ = _startpos__1_ in @@ -31680,7 +40034,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 2817 "src/ocaml/preprocess/parser_raw.mly" +# 2957 "src/ocaml/preprocess/parser_raw.mly" ( let constraint_loc, label, e = match eo with | None -> @@ -31690,13 +40044,13 @@ module Tables = struct (_startpos_c_, _endpos), label, e in label, mkexp_opt_constraint ~loc:constraint_loc e c ) -# 31694 "src/ocaml/preprocess/parser_raw.ml" +# 40048 "src/ocaml/preprocess/parser_raw.ml" in -# 1160 "src/ocaml/preprocess/parser_raw.mly" +# 1218 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 31700 "src/ocaml/preprocess/parser_raw.ml" +# 40054 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31734,7 +40088,7 @@ module Tables = struct } = _menhir_stack in let x : unit = Obj.magic x in let eo : (Parsetree.expression option) = Obj.magic eo in - let c : ((Parsetree.core_type option * Parsetree.core_type option) option) = Obj.magic c in + let c : (Parsetree.type_constraint option) = Obj.magic c in let _1 : (Longident.t) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -31742,7 +40096,7 @@ module Tables = struct let _v : ((Longident.t Location.loc * Parsetree.expression) list) = let _2 = # 126 "" ( Some x ) -# 31746 "src/ocaml/preprocess/parser_raw.ml" +# 40100 "src/ocaml/preprocess/parser_raw.ml" in let x = let label = @@ -31750,9 +40104,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 31756 "src/ocaml/preprocess/parser_raw.ml" +# 40110 "src/ocaml/preprocess/parser_raw.ml" in let _startpos_label_ = _startpos__1_ in @@ -31760,7 +40114,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 2817 "src/ocaml/preprocess/parser_raw.mly" +# 2957 "src/ocaml/preprocess/parser_raw.mly" ( let constraint_loc, label, e = match eo with | None -> @@ -31770,13 +40124,13 @@ module Tables = struct (_startpos_c_, _endpos), label, e in label, mkexp_opt_constraint ~loc:constraint_loc e c ) -# 31774 "src/ocaml/preprocess/parser_raw.ml" +# 40128 "src/ocaml/preprocess/parser_raw.ml" in -# 1160 "src/ocaml/preprocess/parser_raw.mly" +# 1218 "src/ocaml/preprocess/parser_raw.mly" ( [x] ) -# 31780 "src/ocaml/preprocess/parser_raw.ml" +# 40134 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31821,7 +40175,7 @@ module Tables = struct let xs : ((Longident.t Location.loc * Parsetree.expression) list) = Obj.magic xs in let _2 : unit = Obj.magic _2 in let eo : (Parsetree.expression option) = Obj.magic eo in - let c : ((Parsetree.core_type option * Parsetree.core_type option) option) = Obj.magic c in + let c : (Parsetree.type_constraint option) = Obj.magic c in let _1 : (Longident.t) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -31832,9 +40186,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 31838 "src/ocaml/preprocess/parser_raw.ml" +# 40192 "src/ocaml/preprocess/parser_raw.ml" in let _startpos_label_ = _startpos__1_ in @@ -31842,7 +40196,7 @@ module Tables = struct let _symbolstartpos = _startpos_label_ in let _sloc = (_symbolstartpos, _endpos) in -# 2817 "src/ocaml/preprocess/parser_raw.mly" +# 2957 "src/ocaml/preprocess/parser_raw.mly" ( let constraint_loc, label, e = match eo with | None -> @@ -31852,13 +40206,13 @@ module Tables = struct (_startpos_c_, _endpos), label, e in label, mkexp_opt_constraint ~loc:constraint_loc e c ) -# 31856 "src/ocaml/preprocess/parser_raw.ml" +# 40210 "src/ocaml/preprocess/parser_raw.ml" in -# 1164 "src/ocaml/preprocess/parser_raw.mly" +# 1222 "src/ocaml/preprocess/parser_raw.mly" ( x :: xs ) -# 31862 "src/ocaml/preprocess/parser_raw.ml" +# 40216 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31880,42 +40234,15 @@ module Tables = struct let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in - let _v : (Parsetree.expression) = -# 2313 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 31887 "src/ocaml/preprocess/parser_raw.ml" + let _v : (Parsetree.expression) = let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 40241 "src/ocaml/preprocess/parser_raw.ml" in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - } = _menhir_stack in - let _2 : unit = Obj.magic _2 in - let _1 : (Parsetree.expression) = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__2_ in - let _v : (Parsetree.expression) = -# 2314 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 31919 "src/ocaml/preprocess/parser_raw.ml" + +# 2427 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 40246 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -31928,107 +40255,97 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; }; }; } = _menhir_stack in - let _3 : (Parsetree.expression) = Obj.magic _3 in - let _2 : unit = Obj.magic _2 in - let _1 : (Parsetree.expression) = Obj.magic _1 in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in + let _1_inlined1 : (string Location.loc option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__3_ in + let _endpos = _endpos_xs_ in let _v : (Parsetree.expression) = let _1 = - let _1 = -# 2316 "src/ocaml/preprocess/parser_raw.mly" - ( Pexp_sequence(_1, _3) ) -# 31959 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos__1_ = _endpos__3_ in - let _endpos = _endpos__1_ in + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 40295 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 40300 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 40306 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 40317 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 40323 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" - ( mkexp ~loc:_sloc _1 ) -# 31968 "src/ocaml/preprocess/parser_raw.ml" +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 40343 "src/ocaml/preprocess/parser_raw.ml" in -# 2317 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 31974 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - }; - } = _menhir_stack in - let _5 : (Parsetree.expression) = Obj.magic _5 in - let _4 : (string Location.loc) = Obj.magic _4 in - let _3 : unit = Obj.magic _3 in - let _2 : unit = Obj.magic _2 in - let _1 : (Parsetree.expression) = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__5_ in - let _v : (Parsetree.expression) = let _endpos = _endpos__5_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 2319 "src/ocaml/preprocess/parser_raw.mly" - ( let seq = mkexp ~loc:_sloc (Pexp_sequence (_1, _5)) in - let payload = PStr [mkstrexp seq []] in - mkexp ~loc:_sloc (Pexp_extension (_4, payload)) ) -# 32032 "src/ocaml/preprocess/parser_raw.ml" +# 2427 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 40349 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32096,18 +40413,18 @@ module Tables = struct let _v : (Parsetree.type_exception * string Location.loc option) = let attrs = let _1 = _1_inlined4 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32102 "src/ocaml/preprocess/parser_raw.ml" +# 40419 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs_ = _endpos__1_inlined4_ in let attrs2 = let _1 = _1_inlined3 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32111 "src/ocaml/preprocess/parser_raw.ml" +# 40428 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -32117,17 +40434,17 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 32123 "src/ocaml/preprocess/parser_raw.ml" +# 40440 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32131 "src/ocaml/preprocess/parser_raw.ml" +# 40448 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs_ in @@ -32135,14 +40452,14 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3293 "src/ocaml/preprocess/parser_raw.mly" +# 3433 "src/ocaml/preprocess/parser_raw.mly" ( let vars, args, res = vars_args_res in let loc = make_loc (_startpos, _endpos_attrs2_) in let docs = symbol_docs _sloc in Te.mk_exception ~attrs (Te.decl id ~vars ~args ?res ~attrs:(attrs1 @ attrs2) ~loc ~docs) , ext ) -# 32146 "src/ocaml/preprocess/parser_raw.ml" +# 40463 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32168,21 +40485,21 @@ module Tables = struct let _1 = # 260 "" ( List.flatten xss ) -# 32172 "src/ocaml/preprocess/parser_raw.ml" +# 40489 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 983 "src/ocaml/preprocess/parser_raw.mly" +# 1020 "src/ocaml/preprocess/parser_raw.mly" ( extra_sig _startpos _endpos _1 ) -# 32180 "src/ocaml/preprocess/parser_raw.ml" +# 40497 "src/ocaml/preprocess/parser_raw.ml" in -# 1752 "src/ocaml/preprocess/parser_raw.mly" +# 1823 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32186 "src/ocaml/preprocess/parser_raw.ml" +# 40503 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32214,9 +40531,9 @@ module Tables = struct let _v : (Parsetree.signature_item) = let _2 = let _1 = _1_inlined1 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32220 "src/ocaml/preprocess/parser_raw.ml" +# 40537 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__2_ = _endpos__1_inlined1_ in @@ -32224,10 +40541,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1767 "src/ocaml/preprocess/parser_raw.mly" +# 1838 "src/ocaml/preprocess/parser_raw.mly" ( let docs = symbol_docs _sloc in mksig ~loc:_sloc (Psig_extension (_1, (add_docs_attrs docs _2))) ) -# 32231 "src/ocaml/preprocess/parser_raw.ml" +# 40548 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32251,23 +40568,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1771 "src/ocaml/preprocess/parser_raw.mly" +# 1842 "src/ocaml/preprocess/parser_raw.mly" ( Psig_attribute _1 ) -# 32257 "src/ocaml/preprocess/parser_raw.ml" +# 40574 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1031 "src/ocaml/preprocess/parser_raw.mly" +# 1068 "src/ocaml/preprocess/parser_raw.mly" ( mksig ~loc:_sloc _1 ) -# 32265 "src/ocaml/preprocess/parser_raw.ml" +# 40582 "src/ocaml/preprocess/parser_raw.ml" in -# 1773 "src/ocaml/preprocess/parser_raw.mly" +# 1844 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32271 "src/ocaml/preprocess/parser_raw.ml" +# 40588 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32291,23 +40608,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1776 "src/ocaml/preprocess/parser_raw.mly" +# 1847 "src/ocaml/preprocess/parser_raw.mly" ( psig_value _1 ) -# 32297 "src/ocaml/preprocess/parser_raw.ml" +# 40614 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32305 "src/ocaml/preprocess/parser_raw.ml" +# 40622 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32311 "src/ocaml/preprocess/parser_raw.ml" +# 40628 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32331,23 +40648,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1778 "src/ocaml/preprocess/parser_raw.mly" +# 1849 "src/ocaml/preprocess/parser_raw.mly" ( psig_value _1 ) -# 32337 "src/ocaml/preprocess/parser_raw.ml" +# 40654 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32345 "src/ocaml/preprocess/parser_raw.ml" +# 40662 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32351 "src/ocaml/preprocess/parser_raw.ml" +# 40668 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32382,26 +40699,26 @@ module Tables = struct let _1 = let _1 = let _1 = -# 1221 "src/ocaml/preprocess/parser_raw.mly" +# 1279 "src/ocaml/preprocess/parser_raw.mly" ( let (x, b) = a in x, b :: bs ) -# 32388 "src/ocaml/preprocess/parser_raw.ml" +# 40705 "src/ocaml/preprocess/parser_raw.ml" in -# 3112 "src/ocaml/preprocess/parser_raw.mly" +# 3252 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32393 "src/ocaml/preprocess/parser_raw.ml" +# 40710 "src/ocaml/preprocess/parser_raw.ml" in -# 3095 "src/ocaml/preprocess/parser_raw.mly" +# 3235 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32399 "src/ocaml/preprocess/parser_raw.ml" +# 40716 "src/ocaml/preprocess/parser_raw.ml" in -# 1780 "src/ocaml/preprocess/parser_raw.mly" +# 1851 "src/ocaml/preprocess/parser_raw.mly" ( psig_type _1 ) -# 32405 "src/ocaml/preprocess/parser_raw.ml" +# 40722 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_bs_, _startpos_a_) in @@ -32409,15 +40726,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32415 "src/ocaml/preprocess/parser_raw.ml" +# 40732 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32421 "src/ocaml/preprocess/parser_raw.ml" +# 40738 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32452,26 +40769,26 @@ module Tables = struct let _1 = let _1 = let _1 = -# 1221 "src/ocaml/preprocess/parser_raw.mly" +# 1279 "src/ocaml/preprocess/parser_raw.mly" ( let (x, b) = a in x, b :: bs ) -# 32458 "src/ocaml/preprocess/parser_raw.ml" +# 40775 "src/ocaml/preprocess/parser_raw.ml" in -# 3112 "src/ocaml/preprocess/parser_raw.mly" +# 3252 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32463 "src/ocaml/preprocess/parser_raw.ml" +# 40780 "src/ocaml/preprocess/parser_raw.ml" in -# 3100 "src/ocaml/preprocess/parser_raw.mly" +# 3240 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32469 "src/ocaml/preprocess/parser_raw.ml" +# 40786 "src/ocaml/preprocess/parser_raw.ml" in -# 1782 "src/ocaml/preprocess/parser_raw.mly" +# 1853 "src/ocaml/preprocess/parser_raw.mly" ( psig_typesubst _1 ) -# 32475 "src/ocaml/preprocess/parser_raw.ml" +# 40792 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_bs_, _startpos_a_) in @@ -32479,15 +40796,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32485 "src/ocaml/preprocess/parser_raw.ml" +# 40802 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32491 "src/ocaml/preprocess/parser_raw.ml" +# 40808 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32572,16 +40889,16 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32578 "src/ocaml/preprocess/parser_raw.ml" +# 40895 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in let cs = -# 1213 "src/ocaml/preprocess/parser_raw.mly" +# 1271 "src/ocaml/preprocess/parser_raw.mly" ( List.rev xs ) -# 32585 "src/ocaml/preprocess/parser_raw.ml" +# 40902 "src/ocaml/preprocess/parser_raw.ml" in let tid = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in @@ -32589,46 +40906,46 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 32595 "src/ocaml/preprocess/parser_raw.ml" +# 40912 "src/ocaml/preprocess/parser_raw.ml" in let _4 = -# 3872 "src/ocaml/preprocess/parser_raw.mly" +# 4068 "src/ocaml/preprocess/parser_raw.mly" ( Recursive ) -# 32601 "src/ocaml/preprocess/parser_raw.ml" +# 40918 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32608 "src/ocaml/preprocess/parser_raw.ml" +# 40925 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3367 "src/ocaml/preprocess/parser_raw.mly" +# 3507 "src/ocaml/preprocess/parser_raw.mly" ( let docs = symbol_docs _sloc in let attrs = attrs1 @ attrs2 in Te.mk tid cs ~params ~priv ~attrs ~docs, ext ) -# 32620 "src/ocaml/preprocess/parser_raw.ml" +# 40937 "src/ocaml/preprocess/parser_raw.ml" in -# 3354 "src/ocaml/preprocess/parser_raw.mly" +# 3494 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32626 "src/ocaml/preprocess/parser_raw.ml" +# 40943 "src/ocaml/preprocess/parser_raw.ml" in -# 1784 "src/ocaml/preprocess/parser_raw.mly" +# 1855 "src/ocaml/preprocess/parser_raw.mly" ( psig_typext _1 ) -# 32632 "src/ocaml/preprocess/parser_raw.ml" +# 40949 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined3_ in @@ -32636,15 +40953,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32642 "src/ocaml/preprocess/parser_raw.ml" +# 40959 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32648 "src/ocaml/preprocess/parser_raw.ml" +# 40965 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32736,16 +41053,16 @@ module Tables = struct let attrs2 = let _1 = _1_inlined4 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32742 "src/ocaml/preprocess/parser_raw.ml" +# 41059 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined4_ in let cs = -# 1213 "src/ocaml/preprocess/parser_raw.mly" +# 1271 "src/ocaml/preprocess/parser_raw.mly" ( List.rev xs ) -# 32749 "src/ocaml/preprocess/parser_raw.ml" +# 41066 "src/ocaml/preprocess/parser_raw.ml" in let tid = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in @@ -32753,9 +41070,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 32759 "src/ocaml/preprocess/parser_raw.ml" +# 41076 "src/ocaml/preprocess/parser_raw.ml" in let _4 = @@ -32764,41 +41081,41 @@ module Tables = struct let _startpos = _startpos__1_ in let _loc = (_startpos, _endpos) in -# 3874 "src/ocaml/preprocess/parser_raw.mly" +# 4070 "src/ocaml/preprocess/parser_raw.mly" ( not_expecting _loc "nonrec flag"; Recursive ) -# 32770 "src/ocaml/preprocess/parser_raw.ml" +# 41087 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32778 "src/ocaml/preprocess/parser_raw.ml" +# 41095 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3367 "src/ocaml/preprocess/parser_raw.mly" +# 3507 "src/ocaml/preprocess/parser_raw.mly" ( let docs = symbol_docs _sloc in let attrs = attrs1 @ attrs2 in Te.mk tid cs ~params ~priv ~attrs ~docs, ext ) -# 32790 "src/ocaml/preprocess/parser_raw.ml" +# 41107 "src/ocaml/preprocess/parser_raw.ml" in -# 3354 "src/ocaml/preprocess/parser_raw.mly" +# 3494 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32796 "src/ocaml/preprocess/parser_raw.ml" +# 41113 "src/ocaml/preprocess/parser_raw.ml" in -# 1784 "src/ocaml/preprocess/parser_raw.mly" +# 1855 "src/ocaml/preprocess/parser_raw.mly" ( psig_typext _1 ) -# 32802 "src/ocaml/preprocess/parser_raw.ml" +# 41119 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined4_ in @@ -32806,15 +41123,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32812 "src/ocaml/preprocess/parser_raw.ml" +# 41129 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32818 "src/ocaml/preprocess/parser_raw.ml" +# 41135 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32838,23 +41155,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1786 "src/ocaml/preprocess/parser_raw.mly" +# 1857 "src/ocaml/preprocess/parser_raw.mly" ( psig_exception _1 ) -# 32844 "src/ocaml/preprocess/parser_raw.ml" +# 41161 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32852 "src/ocaml/preprocess/parser_raw.ml" +# 41169 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32858 "src/ocaml/preprocess/parser_raw.ml" +# 41175 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -32917,9 +41234,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32923 "src/ocaml/preprocess/parser_raw.ml" +# 41240 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -32929,37 +41246,37 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 32935 "src/ocaml/preprocess/parser_raw.ml" +# 41252 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32943 "src/ocaml/preprocess/parser_raw.ml" +# 41260 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1817 "src/ocaml/preprocess/parser_raw.mly" +# 1888 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in let docs = symbol_docs _sloc in Md.mk name body ~attrs ~loc ~docs, ext ) -# 32957 "src/ocaml/preprocess/parser_raw.ml" +# 41274 "src/ocaml/preprocess/parser_raw.ml" in -# 1788 "src/ocaml/preprocess/parser_raw.mly" +# 1859 "src/ocaml/preprocess/parser_raw.mly" ( let (body, ext) = _1 in (Psig_module body, ext) ) -# 32963 "src/ocaml/preprocess/parser_raw.ml" +# 41280 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined3_ in @@ -32967,15 +41284,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 32973 "src/ocaml/preprocess/parser_raw.ml" +# 41290 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 32979 "src/ocaml/preprocess/parser_raw.ml" +# 41296 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33045,9 +41362,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined4 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33051 "src/ocaml/preprocess/parser_raw.ml" +# 41368 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined4_ in @@ -33058,9 +41375,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 33064 "src/ocaml/preprocess/parser_raw.ml" +# 41381 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos_id_, _startpos_id_) = (_endpos__1_, _startpos__1_) in @@ -33068,9 +41385,9 @@ module Tables = struct let _symbolstartpos = _startpos_id_ in let _sloc = (_symbolstartpos, _endpos) in -# 1854 "src/ocaml/preprocess/parser_raw.mly" +# 1929 "src/ocaml/preprocess/parser_raw.mly" ( Mty.alias ~loc:(make_loc _sloc) id ) -# 33074 "src/ocaml/preprocess/parser_raw.ml" +# 41391 "src/ocaml/preprocess/parser_raw.ml" in let name = @@ -33079,37 +41396,37 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 33085 "src/ocaml/preprocess/parser_raw.ml" +# 41402 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33093 "src/ocaml/preprocess/parser_raw.ml" +# 41410 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1845 "src/ocaml/preprocess/parser_raw.mly" +# 1920 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in let docs = symbol_docs _sloc in Md.mk name body ~attrs ~loc ~docs, ext ) -# 33107 "src/ocaml/preprocess/parser_raw.ml" +# 41424 "src/ocaml/preprocess/parser_raw.ml" in -# 1790 "src/ocaml/preprocess/parser_raw.mly" +# 1861 "src/ocaml/preprocess/parser_raw.mly" ( let (body, ext) = _1 in (Psig_module body, ext) ) -# 33113 "src/ocaml/preprocess/parser_raw.ml" +# 41430 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined4_ in @@ -33117,15 +41434,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 33123 "src/ocaml/preprocess/parser_raw.ml" +# 41440 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33129 "src/ocaml/preprocess/parser_raw.ml" +# 41446 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33149,23 +41466,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1792 "src/ocaml/preprocess/parser_raw.mly" +# 1863 "src/ocaml/preprocess/parser_raw.mly" ( let (body, ext) = _1 in (Psig_modsubst body, ext) ) -# 33155 "src/ocaml/preprocess/parser_raw.ml" +# 41472 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 33163 "src/ocaml/preprocess/parser_raw.ml" +# 41480 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33169 "src/ocaml/preprocess/parser_raw.ml" +# 41486 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33251,9 +41568,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33257 "src/ocaml/preprocess/parser_raw.ml" +# 41574 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -33263,49 +41580,49 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 33269 "src/ocaml/preprocess/parser_raw.ml" +# 41586 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33277 "src/ocaml/preprocess/parser_raw.ml" +# 41594 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1890 "src/ocaml/preprocess/parser_raw.mly" +# 1965 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in let docs = symbol_docs _sloc in ext, Md.mk name mty ~attrs ~loc ~docs ) -# 33291 "src/ocaml/preprocess/parser_raw.ml" +# 41608 "src/ocaml/preprocess/parser_raw.ml" in -# 1221 "src/ocaml/preprocess/parser_raw.mly" +# 1279 "src/ocaml/preprocess/parser_raw.mly" ( let (x, b) = a in x, b :: bs ) -# 33297 "src/ocaml/preprocess/parser_raw.ml" +# 41614 "src/ocaml/preprocess/parser_raw.ml" in -# 1879 "src/ocaml/preprocess/parser_raw.mly" +# 1954 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33303 "src/ocaml/preprocess/parser_raw.ml" +# 41620 "src/ocaml/preprocess/parser_raw.ml" in -# 1794 "src/ocaml/preprocess/parser_raw.mly" +# 1865 "src/ocaml/preprocess/parser_raw.mly" ( let (ext, l) = _1 in (Psig_recmodule l, ext) ) -# 33309 "src/ocaml/preprocess/parser_raw.ml" +# 41626 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos_bs_ in @@ -33313,15 +41630,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 33319 "src/ocaml/preprocess/parser_raw.ml" +# 41636 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33325 "src/ocaml/preprocess/parser_raw.ml" +# 41642 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33345,23 +41662,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1796 "src/ocaml/preprocess/parser_raw.mly" +# 1867 "src/ocaml/preprocess/parser_raw.mly" ( let (body, ext) = _1 in (Psig_modtype body, ext) ) -# 33351 "src/ocaml/preprocess/parser_raw.ml" +# 41668 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 33359 "src/ocaml/preprocess/parser_raw.ml" +# 41676 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33365 "src/ocaml/preprocess/parser_raw.ml" +# 41682 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33385,23 +41702,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1798 "src/ocaml/preprocess/parser_raw.mly" +# 1869 "src/ocaml/preprocess/parser_raw.mly" ( let (body, ext) = _1 in (Psig_modtypesubst body, ext) ) -# 33391 "src/ocaml/preprocess/parser_raw.ml" +# 41708 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 33399 "src/ocaml/preprocess/parser_raw.ml" +# 41716 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33405 "src/ocaml/preprocess/parser_raw.ml" +# 41722 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33425,23 +41742,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1800 "src/ocaml/preprocess/parser_raw.mly" +# 1871 "src/ocaml/preprocess/parser_raw.mly" ( let (body, ext) = _1 in (Psig_open body, ext) ) -# 33431 "src/ocaml/preprocess/parser_raw.ml" +# 41748 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 33439 "src/ocaml/preprocess/parser_raw.ml" +# 41756 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33445 "src/ocaml/preprocess/parser_raw.ml" +# 41762 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33497,38 +41814,38 @@ module Tables = struct let attrs2 = let _1 = _1_inlined2 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33503 "src/ocaml/preprocess/parser_raw.ml" +# 41820 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined2_ in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33512 "src/ocaml/preprocess/parser_raw.ml" +# 41829 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1640 "src/ocaml/preprocess/parser_raw.mly" +# 1705 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in let docs = symbol_docs _sloc in Incl.mk thing ~attrs ~loc ~docs, ext ) -# 33526 "src/ocaml/preprocess/parser_raw.ml" +# 41843 "src/ocaml/preprocess/parser_raw.ml" in -# 1802 "src/ocaml/preprocess/parser_raw.mly" +# 1873 "src/ocaml/preprocess/parser_raw.mly" ( psig_include _1 ) -# 33532 "src/ocaml/preprocess/parser_raw.ml" +# 41849 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined2_ in @@ -33536,15 +41853,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 33542 "src/ocaml/preprocess/parser_raw.ml" +# 41859 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33548 "src/ocaml/preprocess/parser_raw.ml" +# 41865 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33621,9 +41938,9 @@ module Tables = struct let cty : (Parsetree.class_type) = Obj.magic cty in let _7 : unit = Obj.magic _7 in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 33627 "src/ocaml/preprocess/parser_raw.ml" +# 41944 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in let virt : (Asttypes.virtual_flag) = Obj.magic virt in @@ -33641,9 +41958,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33647 "src/ocaml/preprocess/parser_raw.ml" +# 41964 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -33653,24 +41970,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 33659 "src/ocaml/preprocess/parser_raw.ml" +# 41976 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33667 "src/ocaml/preprocess/parser_raw.ml" +# 41984 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2245 "src/ocaml/preprocess/parser_raw.mly" +# 2320 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in @@ -33678,25 +41995,25 @@ module Tables = struct ext, Ci.mk id cty ~virt ~params ~attrs ~loc ~docs ) -# 33682 "src/ocaml/preprocess/parser_raw.ml" +# 41999 "src/ocaml/preprocess/parser_raw.ml" in -# 1221 "src/ocaml/preprocess/parser_raw.mly" +# 1279 "src/ocaml/preprocess/parser_raw.mly" ( let (x, b) = a in x, b :: bs ) -# 33688 "src/ocaml/preprocess/parser_raw.ml" +# 42005 "src/ocaml/preprocess/parser_raw.ml" in -# 2233 "src/ocaml/preprocess/parser_raw.mly" +# 2308 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33694 "src/ocaml/preprocess/parser_raw.ml" +# 42011 "src/ocaml/preprocess/parser_raw.ml" in -# 1804 "src/ocaml/preprocess/parser_raw.mly" +# 1875 "src/ocaml/preprocess/parser_raw.mly" ( let (ext, l) = _1 in (Psig_class l, ext) ) -# 33700 "src/ocaml/preprocess/parser_raw.ml" +# 42017 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos_bs_ in @@ -33704,15 +42021,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 33710 "src/ocaml/preprocess/parser_raw.ml" +# 42027 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33716 "src/ocaml/preprocess/parser_raw.ml" +# 42033 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33736,23 +42053,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.signature_item) = let _1 = let _1 = -# 1806 "src/ocaml/preprocess/parser_raw.mly" +# 1877 "src/ocaml/preprocess/parser_raw.mly" ( let (ext, l) = _1 in (Psig_class_type l, ext) ) -# 33742 "src/ocaml/preprocess/parser_raw.ml" +# 42059 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1048 "src/ocaml/preprocess/parser_raw.mly" +# 1085 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mksig_ext ~loc:_sloc _1 ) -# 33750 "src/ocaml/preprocess/parser_raw.ml" +# 42067 "src/ocaml/preprocess/parser_raw.ml" in -# 1808 "src/ocaml/preprocess/parser_raw.mly" +# 1879 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33756 "src/ocaml/preprocess/parser_raw.ml" +# 42073 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33775,9 +42092,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.constant) = -# 3697 "src/ocaml/preprocess/parser_raw.mly" +# 3893 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 33781 "src/ocaml/preprocess/parser_raw.ml" +# 42098 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33802,18 +42119,18 @@ module Tables = struct }; } = _menhir_stack in let _2 : ( -# 779 "src/ocaml/preprocess/parser_raw.mly" +# 824 "src/ocaml/preprocess/parser_raw.mly" (string * char option) -# 33808 "src/ocaml/preprocess/parser_raw.ml" +# 42125 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.constant) = -# 3698 "src/ocaml/preprocess/parser_raw.mly" +# 3894 "src/ocaml/preprocess/parser_raw.mly" ( let (n, m) = _2 in Pconst_integer("-" ^ n, m) ) -# 33817 "src/ocaml/preprocess/parser_raw.ml" +# 42134 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33838,18 +42155,18 @@ module Tables = struct }; } = _menhir_stack in let _2 : ( -# 758 "src/ocaml/preprocess/parser_raw.mly" +# 803 "src/ocaml/preprocess/parser_raw.mly" (string * char option) -# 33844 "src/ocaml/preprocess/parser_raw.ml" +# 42161 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.constant) = -# 3699 "src/ocaml/preprocess/parser_raw.mly" +# 3895 "src/ocaml/preprocess/parser_raw.mly" ( let (f, m) = _2 in Pconst_float("-" ^ f, m) ) -# 33853 "src/ocaml/preprocess/parser_raw.ml" +# 42170 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33874,18 +42191,18 @@ module Tables = struct }; } = _menhir_stack in let _2 : ( -# 779 "src/ocaml/preprocess/parser_raw.mly" +# 824 "src/ocaml/preprocess/parser_raw.mly" (string * char option) -# 33880 "src/ocaml/preprocess/parser_raw.ml" +# 42197 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.constant) = -# 3700 "src/ocaml/preprocess/parser_raw.mly" +# 3896 "src/ocaml/preprocess/parser_raw.mly" ( let (n, m) = _2 in Pconst_integer (n, m) ) -# 33889 "src/ocaml/preprocess/parser_raw.ml" +# 42206 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33910,18 +42227,259 @@ module Tables = struct }; } = _menhir_stack in let _2 : ( -# 758 "src/ocaml/preprocess/parser_raw.mly" +# 803 "src/ocaml/preprocess/parser_raw.mly" (string * char option) -# 33916 "src/ocaml/preprocess/parser_raw.ml" +# 42233 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.constant) = -# 3701 "src/ocaml/preprocess/parser_raw.mly" +# 3897 "src/ocaml/preprocess/parser_raw.mly" ( let (f, m) = _2 in Pconst_float(f, m) ) -# 33925 "src/ocaml/preprocess/parser_raw.ml" +# 42242 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _3 : unit = Obj.magic _3 in + let _1_inlined1 : ((Longident.t Location.loc * Parsetree.pattern) list * unit option) = Obj.magic _1_inlined1 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__3_ in + let _v : (Parsetree.pattern) = let _1 = + let _1 = + let _2 = + let _1 = _1_inlined1 in + +# 3164 "src/ocaml/preprocess/parser_raw.mly" + ( let fields, closed = _1 in + let closed = match closed with Some () -> Open | None -> Closed in + fields, closed ) +# 42287 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3135 "src/ocaml/preprocess/parser_raw.mly" + ( let (fields, closed) = _2 in + Ppat_record(fields, closed) ) +# 42294 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__1_ = _endpos__3_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1062 "src/ocaml/preprocess/parser_raw.mly" + ( mkpat ~loc:_sloc _1 ) +# 42304 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3149 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 42310 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = ps; + MenhirLib.EngineTypes.startp = _startpos_ps_; + MenhirLib.EngineTypes.endp = _endpos_ps_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _3 : unit = Obj.magic _3 in + let ps : (Parsetree.pattern list) = Obj.magic ps in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__3_ in + let _v : (Parsetree.pattern) = let _1 = + let _1 = + let _2 = +# 3158 "src/ocaml/preprocess/parser_raw.mly" + ( ps ) +# 42351 "src/ocaml/preprocess/parser_raw.ml" + in + let _loc__3_ = (_startpos__3_, _endpos__3_) in + +# 3140 "src/ocaml/preprocess/parser_raw.mly" + ( fst (mktailpat _loc__3_ _2) ) +# 42357 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__1_ = _endpos__3_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1062 "src/ocaml/preprocess/parser_raw.mly" + ( mkpat ~loc:_sloc _1 ) +# 42367 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3149 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 42373 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = ps; + MenhirLib.EngineTypes.startp = _startpos_ps_; + MenhirLib.EngineTypes.endp = _endpos_ps_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _3 : unit = Obj.magic _3 in + let ps : (Parsetree.pattern list) = Obj.magic ps in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__3_ in + let _v : (Parsetree.pattern) = let _1 = + let _1 = + let _2 = +# 3158 "src/ocaml/preprocess/parser_raw.mly" + ( ps ) +# 42414 "src/ocaml/preprocess/parser_raw.ml" + in + +# 3144 "src/ocaml/preprocess/parser_raw.mly" + ( Ppat_array _2 ) +# 42419 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__1_ = _endpos__3_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1062 "src/ocaml/preprocess/parser_raw.mly" + ( mkpat ~loc:_sloc _1 ) +# 42429 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3149 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 42435 "src/ocaml/preprocess/parser_raw.ml" + in + { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = Obj.repr _v; + MenhirLib.EngineTypes.startp = _startpos; + MenhirLib.EngineTypes.endp = _endpos; + MenhirLib.EngineTypes.next = _menhir_stack; + }); + (fun _menhir_env -> + let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in + let { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + } = _menhir_stack in + let _2 : unit = Obj.magic _2 in + let _1 : unit = Obj.magic _1 in + let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in + let _startpos = _startpos__1_ in + let _endpos = _endpos__2_ in + let _v : (Parsetree.pattern) = let _1 = + let _1 = +# 3146 "src/ocaml/preprocess/parser_raw.mly" + ( Ppat_array [] ) +# 42468 "src/ocaml/preprocess/parser_raw.ml" + in + let _endpos__1_ = _endpos__2_ in + let _endpos = _endpos__1_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in + +# 1062 "src/ocaml/preprocess/parser_raw.mly" + ( mkpat ~loc:_sloc _1 ) +# 42477 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 3149 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 42483 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -33952,107 +42510,30 @@ module Tables = struct }; } = _menhir_stack in let _3 : unit = Obj.magic _3 in - let _1_inlined1 : ((Longident.t Location.loc * Parsetree.pattern) list * unit option) = Obj.magic _1_inlined1 in + let _1_inlined1 : (Parsetree.expression) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in - let _v : (Parsetree.pattern) = let _1 = - let _1 = - let _2 = - let _1 = _1_inlined1 in - -# 3024 "src/ocaml/preprocess/parser_raw.mly" - ( let fields, closed = _1 in - let closed = match closed with Some () -> Open | None -> Closed in - fields, closed ) -# 33970 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 2995 "src/ocaml/preprocess/parser_raw.mly" - ( let (fields, closed) = _2 in - Ppat_record(fields, closed) ) -# 33977 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos__1_ = _endpos__3_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in + let _v : (Parsetree.expression) = let _2 = + let _1 = _1_inlined1 in + let _1 = +# 2389 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 42524 "src/ocaml/preprocess/parser_raw.ml" + in -# 1025 "src/ocaml/preprocess/parser_raw.mly" - ( mkpat ~loc:_sloc _1 ) -# 33987 "src/ocaml/preprocess/parser_raw.ml" +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 42529 "src/ocaml/preprocess/parser_raw.ml" in - -# 3009 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 33993 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = ps; - MenhirLib.EngineTypes.startp = _startpos_ps_; - MenhirLib.EngineTypes.endp = _endpos_ps_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - } = _menhir_stack in - let _3 : unit = Obj.magic _3 in - let ps : (Parsetree.pattern list) = Obj.magic ps in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in - let _v : (Parsetree.pattern) = let _1 = - let _1 = - let _2 = -# 3018 "src/ocaml/preprocess/parser_raw.mly" - ( ps ) -# 34034 "src/ocaml/preprocess/parser_raw.ml" - in - let _loc__3_ = (_startpos__3_, _endpos__3_) in - -# 3000 "src/ocaml/preprocess/parser_raw.mly" - ( fst (mktailpat _loc__3_ _2) ) -# 34040 "src/ocaml/preprocess/parser_raw.ml" - - in - let _endpos__1_ = _endpos__3_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1025 "src/ocaml/preprocess/parser_raw.mly" - ( mkpat ~loc:_sloc _1 ) -# 34050 "src/ocaml/preprocess/parser_raw.ml" - - in + let _startpos = _startpos__1_ in -# 3009 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 34056 "src/ocaml/preprocess/parser_raw.ml" +# 4268 "src/ocaml/preprocess/parser_raw.mly" + ( Fake.Meta.code _startpos _endpos _2 ) +# 42537 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34070,140 +42551,116 @@ module Tables = struct MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = ps; - MenhirLib.EngineTypes.startp = _startpos_ps_; - MenhirLib.EngineTypes.endp = _endpos_ps_; + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined3; + MenhirLib.EngineTypes.startp = _startpos__1_inlined3_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined2; + MenhirLib.EngineTypes.startp = _startpos__1_inlined2_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _; + MenhirLib.EngineTypes.semv = _1_inlined1; + MenhirLib.EngineTypes.startp = _startpos__1_inlined1_; + MenhirLib.EngineTypes.endp = _endpos__1_inlined1_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; }; }; } = _menhir_stack in let _3 : unit = Obj.magic _3 in - let ps : (Parsetree.pattern list) = Obj.magic ps in + let xs : (Parsetree.case list) = Obj.magic xs in + let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in + let _1_inlined2 : (string Location.loc option) = Obj.magic _1_inlined2 in + let _1_inlined1 : unit = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in - let _v : (Parsetree.pattern) = let _1 = + let _v : (Parsetree.expression) = let _2 = + let (_startpos__1_, _1_inlined2, _1_inlined1, _1) = (_startpos__1_inlined1_, _1_inlined3, _1_inlined2, _1_inlined1) in let _1 = - let _2 = -# 3018 "src/ocaml/preprocess/parser_raw.mly" - ( ps ) -# 34097 "src/ocaml/preprocess/parser_raw.ml" - in + let _3 = + let xs = + let xs = +# 253 "" + ( List.rev xs ) +# 42602 "src/ocaml/preprocess/parser_raw.ml" + in + +# 1243 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 42607 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 2893 "src/ocaml/preprocess/parser_raw.mly" + ( xs ) +# 42613 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos__3_ = _endpos_xs_ in + let _2 = + let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in + let _2 = + let _1 = _1_inlined1 in + +# 4227 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 42624 "src/ocaml/preprocess/parser_raw.ml" + + in + +# 4240 "src/ocaml/preprocess/parser_raw.mly" + ( _1, _2 ) +# 42630 "src/ocaml/preprocess/parser_raw.ml" + + in + let _endpos = _endpos__3_ in + let _symbolstartpos = _startpos__1_ in + let _sloc = (_symbolstartpos, _endpos) in -# 3004 "src/ocaml/preprocess/parser_raw.mly" - ( Ppat_array _2 ) -# 34102 "src/ocaml/preprocess/parser_raw.ml" +# 2391 "src/ocaml/preprocess/parser_raw.mly" + ( let loc = make_loc _sloc in + let cases = _3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:_sloc desc _2 + ) +# 42650 "src/ocaml/preprocess/parser_raw.ml" in - let _endpos__1_ = _endpos__3_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" - ( mkpat ~loc:_sloc _1 ) -# 34112 "src/ocaml/preprocess/parser_raw.ml" +# 2535 "src/ocaml/preprocess/parser_raw.mly" + ( _1 ) +# 42656 "src/ocaml/preprocess/parser_raw.ml" in - -# 3009 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 34118 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - } = _menhir_stack in - let _2 : unit = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__2_ in - let _v : (Parsetree.pattern) = let _1 = - let _1 = -# 3006 "src/ocaml/preprocess/parser_raw.mly" - ( Ppat_array [] ) -# 34151 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos__1_ = _endpos__2_ in - let _endpos = _endpos__1_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 1025 "src/ocaml/preprocess/parser_raw.mly" - ( mkpat ~loc:_sloc _1 ) -# 34160 "src/ocaml/preprocess/parser_raw.ml" - - in - -# 3009 "src/ocaml/preprocess/parser_raw.mly" - ( _1 ) -# 34166 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - } = _menhir_stack in - let _3 : unit = Obj.magic _3 in - let _2 : (Parsetree.expression) = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in - let _v : (Parsetree.expression) = let _endpos = _endpos__3_ in let _startpos = _startpos__1_ in -# 4066 "src/ocaml/preprocess/parser_raw.mly" +# 4268 "src/ocaml/preprocess/parser_raw.mly" ( Fake.Meta.code _startpos _endpos _2 ) -# 34207 "src/ocaml/preprocess/parser_raw.ml" +# 42664 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34235,9 +42692,9 @@ module Tables = struct let _v : (Parsetree.expression) = let _endpos = _endpos__2_ in let _startpos = _startpos__1_ in -# 4068 "src/ocaml/preprocess/parser_raw.mly" +# 4270 "src/ocaml/preprocess/parser_raw.mly" ( Fake.Meta.uncode _startpos _endpos _2 ) -# 34241 "src/ocaml/preprocess/parser_raw.ml" +# 42698 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34277,9 +42734,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2485 "src/ocaml/preprocess/parser_raw.mly" +# 2597 "src/ocaml/preprocess/parser_raw.mly" ( reloc_exp ~loc:_sloc _2 ) -# 34283 "src/ocaml/preprocess/parser_raw.ml" +# 42740 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34316,7 +42773,7 @@ module Tables = struct }; } = _menhir_stack in let _4 : unit = Obj.magic _4 in - let _3 : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic _3 in + let _3 : (Parsetree.type_constraint) = Obj.magic _3 in let _2 : (Parsetree.expression) = Obj.magic _2 in let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -34326,9 +42783,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2491 "src/ocaml/preprocess/parser_raw.mly" +# 2603 "src/ocaml/preprocess/parser_raw.mly" ( mkexp_constraint ~loc:_sloc _2 _3 ) -# 34332 "src/ocaml/preprocess/parser_raw.ml" +# 42789 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34380,14 +42837,14 @@ module Tables = struct let _endpos = _endpos__5_ in let _v : (Parsetree.expression) = let _1 = let r = -# 2492 "src/ocaml/preprocess/parser_raw.mly" +# 2604 "src/ocaml/preprocess/parser_raw.mly" ( None ) -# 34386 "src/ocaml/preprocess/parser_raw.ml" +# 42843 "src/ocaml/preprocess/parser_raw.ml" in -# 2375 "src/ocaml/preprocess/parser_raw.mly" +# 2481 "src/ocaml/preprocess/parser_raw.mly" ( array, d, Paren, i, r ) -# 34391 "src/ocaml/preprocess/parser_raw.ml" +# 42848 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in @@ -34395,9 +42852,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2493 "src/ocaml/preprocess/parser_raw.mly" +# 2605 "src/ocaml/preprocess/parser_raw.mly" ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 ) -# 34401 "src/ocaml/preprocess/parser_raw.ml" +# 42858 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34449,14 +42906,14 @@ module Tables = struct let _endpos = _endpos__5_ in let _v : (Parsetree.expression) = let _1 = let r = -# 2492 "src/ocaml/preprocess/parser_raw.mly" +# 2604 "src/ocaml/preprocess/parser_raw.mly" ( None ) -# 34455 "src/ocaml/preprocess/parser_raw.ml" +# 42912 "src/ocaml/preprocess/parser_raw.ml" in -# 2377 "src/ocaml/preprocess/parser_raw.mly" +# 2483 "src/ocaml/preprocess/parser_raw.mly" ( array, d, Brace, i, r ) -# 34460 "src/ocaml/preprocess/parser_raw.ml" +# 42917 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in @@ -34464,9 +42921,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2493 "src/ocaml/preprocess/parser_raw.mly" +# 2605 "src/ocaml/preprocess/parser_raw.mly" ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 ) -# 34470 "src/ocaml/preprocess/parser_raw.ml" +# 42927 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34518,14 +42975,14 @@ module Tables = struct let _endpos = _endpos__5_ in let _v : (Parsetree.expression) = let _1 = let r = -# 2492 "src/ocaml/preprocess/parser_raw.mly" +# 2604 "src/ocaml/preprocess/parser_raw.mly" ( None ) -# 34524 "src/ocaml/preprocess/parser_raw.ml" +# 42981 "src/ocaml/preprocess/parser_raw.ml" in -# 2379 "src/ocaml/preprocess/parser_raw.mly" +# 2485 "src/ocaml/preprocess/parser_raw.mly" ( array, d, Bracket, i, r ) -# 34529 "src/ocaml/preprocess/parser_raw.ml" +# 42986 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in @@ -34533,9 +42990,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2493 "src/ocaml/preprocess/parser_raw.mly" +# 2605 "src/ocaml/preprocess/parser_raw.mly" ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 ) -# 34539 "src/ocaml/preprocess/parser_raw.ml" +# 42996 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34581,9 +43038,9 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 34587 "src/ocaml/preprocess/parser_raw.ml" +# 43044 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _2 in let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -34591,31 +43048,31 @@ module Tables = struct let _endpos = _endpos__5_ in let _v : (Parsetree.expression) = let _1 = let r = -# 2494 "src/ocaml/preprocess/parser_raw.mly" +# 2606 "src/ocaml/preprocess/parser_raw.mly" ( None ) -# 34597 "src/ocaml/preprocess/parser_raw.ml" +# 43054 "src/ocaml/preprocess/parser_raw.ml" in let i = -# 2846 "src/ocaml/preprocess/parser_raw.mly" +# 2986 "src/ocaml/preprocess/parser_raw.mly" ( es ) -# 34602 "src/ocaml/preprocess/parser_raw.ml" +# 43059 "src/ocaml/preprocess/parser_raw.ml" in let d = let _1 = # 124 "" ( None ) -# 34608 "src/ocaml/preprocess/parser_raw.ml" +# 43065 "src/ocaml/preprocess/parser_raw.ml" in -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 34613 "src/ocaml/preprocess/parser_raw.ml" +# 43070 "src/ocaml/preprocess/parser_raw.ml" in -# 2375 "src/ocaml/preprocess/parser_raw.mly" +# 2481 "src/ocaml/preprocess/parser_raw.mly" ( array, d, Paren, i, r ) -# 34619 "src/ocaml/preprocess/parser_raw.ml" +# 43076 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in @@ -34623,9 +43080,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2495 "src/ocaml/preprocess/parser_raw.mly" +# 2607 "src/ocaml/preprocess/parser_raw.mly" ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) -# 34629 "src/ocaml/preprocess/parser_raw.ml" +# 43086 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34683,9 +43140,9 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 34689 "src/ocaml/preprocess/parser_raw.ml" +# 43146 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _2 in let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in let _1 : unit = Obj.magic _1 in @@ -34695,39 +43152,39 @@ module Tables = struct let _endpos = _endpos__5_ in let _v : (Parsetree.expression) = let _1 = let r = -# 2494 "src/ocaml/preprocess/parser_raw.mly" +# 2606 "src/ocaml/preprocess/parser_raw.mly" ( None ) -# 34701 "src/ocaml/preprocess/parser_raw.ml" +# 43158 "src/ocaml/preprocess/parser_raw.ml" in let i = -# 2846 "src/ocaml/preprocess/parser_raw.mly" +# 2986 "src/ocaml/preprocess/parser_raw.mly" ( es ) -# 34706 "src/ocaml/preprocess/parser_raw.ml" +# 43163 "src/ocaml/preprocess/parser_raw.ml" in let d = let _1 = let _2 = _2_inlined1 in let x = -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" (_2) -# 34714 "src/ocaml/preprocess/parser_raw.ml" +# 43171 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 34719 "src/ocaml/preprocess/parser_raw.ml" +# 43176 "src/ocaml/preprocess/parser_raw.ml" in -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 34725 "src/ocaml/preprocess/parser_raw.ml" +# 43182 "src/ocaml/preprocess/parser_raw.ml" in -# 2375 "src/ocaml/preprocess/parser_raw.mly" +# 2481 "src/ocaml/preprocess/parser_raw.mly" ( array, d, Paren, i, r ) -# 34731 "src/ocaml/preprocess/parser_raw.ml" +# 43188 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in @@ -34735,9 +43192,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2495 "src/ocaml/preprocess/parser_raw.mly" +# 2607 "src/ocaml/preprocess/parser_raw.mly" ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) -# 34741 "src/ocaml/preprocess/parser_raw.ml" +# 43198 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34783,9 +43240,9 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 34789 "src/ocaml/preprocess/parser_raw.ml" +# 43246 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _2 in let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -34793,31 +43250,31 @@ module Tables = struct let _endpos = _endpos__5_ in let _v : (Parsetree.expression) = let _1 = let r = -# 2494 "src/ocaml/preprocess/parser_raw.mly" +# 2606 "src/ocaml/preprocess/parser_raw.mly" ( None ) -# 34799 "src/ocaml/preprocess/parser_raw.ml" +# 43256 "src/ocaml/preprocess/parser_raw.ml" in let i = -# 2846 "src/ocaml/preprocess/parser_raw.mly" +# 2986 "src/ocaml/preprocess/parser_raw.mly" ( es ) -# 34804 "src/ocaml/preprocess/parser_raw.ml" +# 43261 "src/ocaml/preprocess/parser_raw.ml" in let d = let _1 = # 124 "" ( None ) -# 34810 "src/ocaml/preprocess/parser_raw.ml" +# 43267 "src/ocaml/preprocess/parser_raw.ml" in -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 34815 "src/ocaml/preprocess/parser_raw.ml" +# 43272 "src/ocaml/preprocess/parser_raw.ml" in -# 2377 "src/ocaml/preprocess/parser_raw.mly" +# 2483 "src/ocaml/preprocess/parser_raw.mly" ( array, d, Brace, i, r ) -# 34821 "src/ocaml/preprocess/parser_raw.ml" +# 43278 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in @@ -34825,9 +43282,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2495 "src/ocaml/preprocess/parser_raw.mly" +# 2607 "src/ocaml/preprocess/parser_raw.mly" ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) -# 34831 "src/ocaml/preprocess/parser_raw.ml" +# 43288 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34885,9 +43342,9 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 34891 "src/ocaml/preprocess/parser_raw.ml" +# 43348 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _2 in let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in let _1 : unit = Obj.magic _1 in @@ -34897,39 +43354,39 @@ module Tables = struct let _endpos = _endpos__5_ in let _v : (Parsetree.expression) = let _1 = let r = -# 2494 "src/ocaml/preprocess/parser_raw.mly" +# 2606 "src/ocaml/preprocess/parser_raw.mly" ( None ) -# 34903 "src/ocaml/preprocess/parser_raw.ml" +# 43360 "src/ocaml/preprocess/parser_raw.ml" in let i = -# 2846 "src/ocaml/preprocess/parser_raw.mly" +# 2986 "src/ocaml/preprocess/parser_raw.mly" ( es ) -# 34908 "src/ocaml/preprocess/parser_raw.ml" +# 43365 "src/ocaml/preprocess/parser_raw.ml" in let d = let _1 = let _2 = _2_inlined1 in let x = -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" (_2) -# 34916 "src/ocaml/preprocess/parser_raw.ml" +# 43373 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 34921 "src/ocaml/preprocess/parser_raw.ml" +# 43378 "src/ocaml/preprocess/parser_raw.ml" in -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 34927 "src/ocaml/preprocess/parser_raw.ml" +# 43384 "src/ocaml/preprocess/parser_raw.ml" in -# 2377 "src/ocaml/preprocess/parser_raw.mly" +# 2483 "src/ocaml/preprocess/parser_raw.mly" ( array, d, Brace, i, r ) -# 34933 "src/ocaml/preprocess/parser_raw.ml" +# 43390 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in @@ -34937,9 +43394,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2495 "src/ocaml/preprocess/parser_raw.mly" +# 2607 "src/ocaml/preprocess/parser_raw.mly" ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) -# 34943 "src/ocaml/preprocess/parser_raw.ml" +# 43400 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -34985,9 +43442,9 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 34991 "src/ocaml/preprocess/parser_raw.ml" +# 43448 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _2 in let array : (Parsetree.expression) = Obj.magic array in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -34995,31 +43452,31 @@ module Tables = struct let _endpos = _endpos__5_ in let _v : (Parsetree.expression) = let _1 = let r = -# 2494 "src/ocaml/preprocess/parser_raw.mly" +# 2606 "src/ocaml/preprocess/parser_raw.mly" ( None ) -# 35001 "src/ocaml/preprocess/parser_raw.ml" +# 43458 "src/ocaml/preprocess/parser_raw.ml" in let i = -# 2846 "src/ocaml/preprocess/parser_raw.mly" +# 2986 "src/ocaml/preprocess/parser_raw.mly" ( es ) -# 35006 "src/ocaml/preprocess/parser_raw.ml" +# 43463 "src/ocaml/preprocess/parser_raw.ml" in let d = let _1 = # 124 "" ( None ) -# 35012 "src/ocaml/preprocess/parser_raw.ml" +# 43469 "src/ocaml/preprocess/parser_raw.ml" in -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 35017 "src/ocaml/preprocess/parser_raw.ml" +# 43474 "src/ocaml/preprocess/parser_raw.ml" in -# 2379 "src/ocaml/preprocess/parser_raw.mly" +# 2485 "src/ocaml/preprocess/parser_raw.mly" ( array, d, Bracket, i, r ) -# 35023 "src/ocaml/preprocess/parser_raw.ml" +# 43480 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in @@ -35027,9 +43484,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2495 "src/ocaml/preprocess/parser_raw.mly" +# 2607 "src/ocaml/preprocess/parser_raw.mly" ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) -# 35033 "src/ocaml/preprocess/parser_raw.ml" +# 43490 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35087,9 +43544,9 @@ module Tables = struct let es : (Parsetree.expression list) = Obj.magic es in let _3 : unit = Obj.magic _3 in let _2 : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 35093 "src/ocaml/preprocess/parser_raw.ml" +# 43550 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _2 in let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in let _1 : unit = Obj.magic _1 in @@ -35099,39 +43556,39 @@ module Tables = struct let _endpos = _endpos__5_ in let _v : (Parsetree.expression) = let _1 = let r = -# 2494 "src/ocaml/preprocess/parser_raw.mly" +# 2606 "src/ocaml/preprocess/parser_raw.mly" ( None ) -# 35105 "src/ocaml/preprocess/parser_raw.ml" +# 43562 "src/ocaml/preprocess/parser_raw.ml" in let i = -# 2846 "src/ocaml/preprocess/parser_raw.mly" +# 2986 "src/ocaml/preprocess/parser_raw.mly" ( es ) -# 35110 "src/ocaml/preprocess/parser_raw.ml" +# 43567 "src/ocaml/preprocess/parser_raw.ml" in let d = let _1 = let _2 = _2_inlined1 in let x = -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" (_2) -# 35118 "src/ocaml/preprocess/parser_raw.ml" +# 43575 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 35123 "src/ocaml/preprocess/parser_raw.ml" +# 43580 "src/ocaml/preprocess/parser_raw.ml" in -# 2391 "src/ocaml/preprocess/parser_raw.mly" +# 2497 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 35129 "src/ocaml/preprocess/parser_raw.ml" +# 43586 "src/ocaml/preprocess/parser_raw.ml" in -# 2379 "src/ocaml/preprocess/parser_raw.mly" +# 2485 "src/ocaml/preprocess/parser_raw.mly" ( array, d, Bracket, i, r ) -# 35135 "src/ocaml/preprocess/parser_raw.ml" +# 43592 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in @@ -35139,9 +43596,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2495 "src/ocaml/preprocess/parser_raw.mly" +# 2607 "src/ocaml/preprocess/parser_raw.mly" ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 ) -# 35145 "src/ocaml/preprocess/parser_raw.ml" +# 43602 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35195,15 +43652,15 @@ module Tables = struct let attrs = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 35201 "src/ocaml/preprocess/parser_raw.ml" +# 43658 "src/ocaml/preprocess/parser_raw.ml" in -# 2508 "src/ocaml/preprocess/parser_raw.mly" +# 2620 "src/ocaml/preprocess/parser_raw.mly" ( e.pexp_desc, (ext, attrs @ e.pexp_attributes) ) -# 35207 "src/ocaml/preprocess/parser_raw.ml" +# 43664 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__5_ in @@ -35211,10 +43668,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2501 "src/ocaml/preprocess/parser_raw.mly" +# 2613 "src/ocaml/preprocess/parser_raw.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 35218 "src/ocaml/preprocess/parser_raw.ml" +# 43675 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35263,24 +43720,24 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 35269 "src/ocaml/preprocess/parser_raw.ml" +# 43726 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 35275 "src/ocaml/preprocess/parser_raw.ml" +# 43732 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__3_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2510 "src/ocaml/preprocess/parser_raw.mly" +# 2622 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_construct (mkloc (Lident "()") (make_loc _sloc), None), _2 ) -# 35284 "src/ocaml/preprocess/parser_raw.ml" +# 43741 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__3_ in @@ -35288,10 +43745,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2501 "src/ocaml/preprocess/parser_raw.mly" +# 2613 "src/ocaml/preprocess/parser_raw.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 35295 "src/ocaml/preprocess/parser_raw.ml" +# 43752 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35341,9 +43798,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 35347 "src/ocaml/preprocess/parser_raw.ml" +# 43804 "src/ocaml/preprocess/parser_raw.ml" in let _2 = @@ -35351,21 +43808,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 35357 "src/ocaml/preprocess/parser_raw.ml" +# 43814 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 35363 "src/ocaml/preprocess/parser_raw.ml" +# 43820 "src/ocaml/preprocess/parser_raw.ml" in -# 2516 "src/ocaml/preprocess/parser_raw.mly" +# 2628 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_new(_3), _2 ) -# 35369 "src/ocaml/preprocess/parser_raw.ml" +# 43826 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined3_ in @@ -35373,10 +43830,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2501 "src/ocaml/preprocess/parser_raw.mly" +# 2613 "src/ocaml/preprocess/parser_raw.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 35380 "src/ocaml/preprocess/parser_raw.ml" +# 43837 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35439,21 +43896,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 35445 "src/ocaml/preprocess/parser_raw.ml" +# 43902 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 35451 "src/ocaml/preprocess/parser_raw.ml" +# 43908 "src/ocaml/preprocess/parser_raw.ml" in -# 2518 "src/ocaml/preprocess/parser_raw.mly" +# 2630 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_pack _4, _3 ) -# 35457 "src/ocaml/preprocess/parser_raw.ml" +# 43914 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__5_ in @@ -35461,10 +43918,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2501 "src/ocaml/preprocess/parser_raw.mly" +# 2613 "src/ocaml/preprocess/parser_raw.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 35468 "src/ocaml/preprocess/parser_raw.ml" +# 43925 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35542,11 +43999,11 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3611 "src/ocaml/preprocess/parser_raw.mly" +# 3807 "src/ocaml/preprocess/parser_raw.mly" ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in let descr = Ptyp_package (lid, cstrs) in mktyp ~loc:_sloc ~attrs descr ) -# 35550 "src/ocaml/preprocess/parser_raw.ml" +# 44007 "src/ocaml/preprocess/parser_raw.ml" in let _3 = @@ -35554,24 +44011,24 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 35560 "src/ocaml/preprocess/parser_raw.ml" +# 44017 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 35566 "src/ocaml/preprocess/parser_raw.ml" +# 44023 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2520 "src/ocaml/preprocess/parser_raw.mly" +# 2632 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_constraint (ghexp ~loc:_sloc (Pexp_pack _4), _6), _3 ) -# 35575 "src/ocaml/preprocess/parser_raw.ml" +# 44032 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__7_ in @@ -35579,10 +44036,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2501 "src/ocaml/preprocess/parser_raw.mly" +# 2613 "src/ocaml/preprocess/parser_raw.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 35586 "src/ocaml/preprocess/parser_raw.ml" +# 44043 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35647,27 +44104,27 @@ module Tables = struct let _1 = # 260 "" ( List.flatten xss ) -# 35651 "src/ocaml/preprocess/parser_raw.ml" +# 44108 "src/ocaml/preprocess/parser_raw.ml" in -# 2059 "src/ocaml/preprocess/parser_raw.mly" +# 2134 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 35656 "src/ocaml/preprocess/parser_raw.ml" +# 44113 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 984 "src/ocaml/preprocess/parser_raw.mly" +# 1021 "src/ocaml/preprocess/parser_raw.mly" ( extra_cstr _startpos _endpos _1 ) -# 35665 "src/ocaml/preprocess/parser_raw.ml" +# 44122 "src/ocaml/preprocess/parser_raw.ml" in -# 2046 "src/ocaml/preprocess/parser_raw.mly" +# 2121 "src/ocaml/preprocess/parser_raw.mly" ( Cstr.mk _1 _2 ) -# 35671 "src/ocaml/preprocess/parser_raw.ml" +# 44128 "src/ocaml/preprocess/parser_raw.ml" in let _2 = @@ -35675,21 +44132,21 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 35681 "src/ocaml/preprocess/parser_raw.ml" +# 44138 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 35687 "src/ocaml/preprocess/parser_raw.ml" +# 44144 "src/ocaml/preprocess/parser_raw.ml" in -# 2526 "src/ocaml/preprocess/parser_raw.mly" +# 2638 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_object _3, _2 ) -# 35693 "src/ocaml/preprocess/parser_raw.ml" +# 44150 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__4_ in @@ -35697,10 +44154,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2501 "src/ocaml/preprocess/parser_raw.mly" +# 2613 "src/ocaml/preprocess/parser_raw.mly" ( let desc, attrs = _1 in mkexp_attrs ~loc:_sloc desc attrs ) -# 35704 "src/ocaml/preprocess/parser_raw.ml" +# 44161 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35729,30 +44186,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 35735 "src/ocaml/preprocess/parser_raw.ml" +# 44192 "src/ocaml/preprocess/parser_raw.ml" in -# 2534 "src/ocaml/preprocess/parser_raw.mly" +# 2646 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_ident (_1) ) -# 35741 "src/ocaml/preprocess/parser_raw.ml" +# 44198 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 35750 "src/ocaml/preprocess/parser_raw.ml" +# 44207 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 35756 "src/ocaml/preprocess/parser_raw.ml" +# 44213 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35776,23 +44233,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.expression) = let _1 = let _1 = -# 2536 "src/ocaml/preprocess/parser_raw.mly" +# 2648 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_constant _1 ) -# 35782 "src/ocaml/preprocess/parser_raw.ml" +# 44239 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 35790 "src/ocaml/preprocess/parser_raw.ml" +# 44247 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 35796 "src/ocaml/preprocess/parser_raw.ml" +# 44253 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35821,30 +44278,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 35827 "src/ocaml/preprocess/parser_raw.ml" +# 44284 "src/ocaml/preprocess/parser_raw.ml" in -# 2538 "src/ocaml/preprocess/parser_raw.mly" +# 2650 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_construct(_1, None) ) -# 35833 "src/ocaml/preprocess/parser_raw.ml" +# 44290 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 35842 "src/ocaml/preprocess/parser_raw.ml" +# 44299 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 35848 "src/ocaml/preprocess/parser_raw.ml" +# 44305 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35868,23 +44325,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.expression) = let _1 = let _1 = -# 2540 "src/ocaml/preprocess/parser_raw.mly" +# 2652 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_variant(_1, None) ) -# 35874 "src/ocaml/preprocess/parser_raw.ml" +# 44331 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 35882 "src/ocaml/preprocess/parser_raw.ml" +# 44339 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 35888 "src/ocaml/preprocess/parser_raw.ml" +# 44345 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35910,9 +44367,9 @@ module Tables = struct } = _menhir_stack in let _2 : (Parsetree.expression) = Obj.magic _2 in let _1 : ( -# 817 "src/ocaml/preprocess/parser_raw.mly" +# 862 "src/ocaml/preprocess/parser_raw.mly" (string) -# 35916 "src/ocaml/preprocess/parser_raw.ml" +# 44373 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in @@ -35924,15 +44381,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1017 "src/ocaml/preprocess/parser_raw.mly" +# 1054 "src/ocaml/preprocess/parser_raw.mly" ( mkoperator ~loc:_sloc _1 ) -# 35930 "src/ocaml/preprocess/parser_raw.ml" +# 44387 "src/ocaml/preprocess/parser_raw.ml" in -# 2542 "src/ocaml/preprocess/parser_raw.mly" +# 2654 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_apply(_1, [Nolabel,_2]) ) -# 35936 "src/ocaml/preprocess/parser_raw.ml" +# 44393 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__2_ in @@ -35940,15 +44397,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 35946 "src/ocaml/preprocess/parser_raw.ml" +# 44403 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 35952 "src/ocaml/preprocess/parser_raw.ml" +# 44409 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -35981,23 +44438,23 @@ module Tables = struct let _1 = let _1 = let _1 = -# 2543 "src/ocaml/preprocess/parser_raw.mly" +# 2655 "src/ocaml/preprocess/parser_raw.mly" ("!") -# 35987 "src/ocaml/preprocess/parser_raw.ml" +# 44444 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1017 "src/ocaml/preprocess/parser_raw.mly" +# 1054 "src/ocaml/preprocess/parser_raw.mly" ( mkoperator ~loc:_sloc _1 ) -# 35995 "src/ocaml/preprocess/parser_raw.ml" +# 44452 "src/ocaml/preprocess/parser_raw.ml" in -# 2544 "src/ocaml/preprocess/parser_raw.mly" +# 2656 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_apply(_1, [Nolabel,_2]) ) -# 36001 "src/ocaml/preprocess/parser_raw.ml" +# 44458 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__2_ in @@ -36005,15 +44462,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 36011 "src/ocaml/preprocess/parser_raw.ml" +# 44468 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 36017 "src/ocaml/preprocess/parser_raw.ml" +# 44474 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36052,14 +44509,14 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _2 = -# 2829 "src/ocaml/preprocess/parser_raw.mly" +# 2969 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 36058 "src/ocaml/preprocess/parser_raw.ml" +# 44515 "src/ocaml/preprocess/parser_raw.ml" in -# 2546 "src/ocaml/preprocess/parser_raw.mly" +# 2658 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_override _2 ) -# 36063 "src/ocaml/preprocess/parser_raw.ml" +# 44520 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__3_ in @@ -36067,15 +44524,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 36073 "src/ocaml/preprocess/parser_raw.ml" +# 44530 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 36079 "src/ocaml/preprocess/parser_raw.ml" +# 44536 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36106,24 +44563,24 @@ module Tables = struct let _endpos = _endpos__2_ in let _v : (Parsetree.expression) = let _1 = let _1 = -# 2552 "src/ocaml/preprocess/parser_raw.mly" +# 2664 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_override [] ) -# 36112 "src/ocaml/preprocess/parser_raw.ml" +# 44569 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 36121 "src/ocaml/preprocess/parser_raw.ml" +# 44578 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 36127 "src/ocaml/preprocess/parser_raw.ml" +# 44584 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36167,15 +44624,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 36173 "src/ocaml/preprocess/parser_raw.ml" +# 44630 "src/ocaml/preprocess/parser_raw.ml" in -# 2554 "src/ocaml/preprocess/parser_raw.mly" +# 2666 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_field(_1, _3) ) -# 36179 "src/ocaml/preprocess/parser_raw.ml" +# 44636 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -36183,15 +44640,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 36189 "src/ocaml/preprocess/parser_raw.ml" +# 44646 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 36195 "src/ocaml/preprocess/parser_raw.ml" +# 44652 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36249,24 +44706,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 36255 "src/ocaml/preprocess/parser_raw.ml" +# 44712 "src/ocaml/preprocess/parser_raw.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1699 "src/ocaml/preprocess/parser_raw.mly" +# 1764 "src/ocaml/preprocess/parser_raw.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 36264 "src/ocaml/preprocess/parser_raw.ml" +# 44721 "src/ocaml/preprocess/parser_raw.ml" in -# 2556 "src/ocaml/preprocess/parser_raw.mly" +# 2668 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_open(od, _4) ) -# 36270 "src/ocaml/preprocess/parser_raw.ml" +# 44727 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__5_ in @@ -36274,15 +44731,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 36280 "src/ocaml/preprocess/parser_raw.ml" +# 44737 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 36286 "src/ocaml/preprocess/parser_raw.ml" +# 44743 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36335,9 +44792,9 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _4 = -# 2829 "src/ocaml/preprocess/parser_raw.mly" +# 2969 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 36341 "src/ocaml/preprocess/parser_raw.ml" +# 44798 "src/ocaml/preprocess/parser_raw.ml" in let od = let _1 = @@ -36345,18 +44802,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 36351 "src/ocaml/preprocess/parser_raw.ml" +# 44808 "src/ocaml/preprocess/parser_raw.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1699 "src/ocaml/preprocess/parser_raw.mly" +# 1764 "src/ocaml/preprocess/parser_raw.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 36360 "src/ocaml/preprocess/parser_raw.ml" +# 44817 "src/ocaml/preprocess/parser_raw.ml" in let _startpos_od_ = _startpos__1_ in @@ -36364,10 +44821,10 @@ module Tables = struct let _symbolstartpos = _startpos_od_ in let _sloc = (_symbolstartpos, _endpos) in -# 2558 "src/ocaml/preprocess/parser_raw.mly" +# 2670 "src/ocaml/preprocess/parser_raw.mly" ( (* TODO: review the location of Pexp_override *) Pexp_open(od, mkexp ~loc:_sloc (Pexp_override _4)) ) -# 36371 "src/ocaml/preprocess/parser_raw.ml" +# 44828 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__5_ in @@ -36375,15 +44832,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 36381 "src/ocaml/preprocess/parser_raw.ml" +# 44838 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 36387 "src/ocaml/preprocess/parser_raw.ml" +# 44844 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36414,9 +44871,9 @@ module Tables = struct }; } = _menhir_stack in let _1_inlined1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 36420 "src/ocaml/preprocess/parser_raw.ml" +# 44877 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined1 in let _2 : unit = Obj.magic _2 in let _1 : (Parsetree.expression) = Obj.magic _1 in @@ -36428,23 +44885,23 @@ module Tables = struct let _3 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 36434 "src/ocaml/preprocess/parser_raw.ml" +# 44891 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 36442 "src/ocaml/preprocess/parser_raw.ml" +# 44899 "src/ocaml/preprocess/parser_raw.ml" in -# 2565 "src/ocaml/preprocess/parser_raw.mly" +# 2677 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_send(_1, _3) ) -# 36448 "src/ocaml/preprocess/parser_raw.ml" +# 44905 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -36452,15 +44909,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 36458 "src/ocaml/preprocess/parser_raw.ml" +# 44915 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 36464 "src/ocaml/preprocess/parser_raw.ml" +# 44921 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36492,9 +44949,9 @@ module Tables = struct } = _menhir_stack in let _3 : (Parsetree.expression) = Obj.magic _3 in let _1_inlined1 : ( -# 828 "src/ocaml/preprocess/parser_raw.mly" +# 873 "src/ocaml/preprocess/parser_raw.mly" (string) -# 36498 "src/ocaml/preprocess/parser_raw.ml" +# 44955 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined1 in let _1 : (Parsetree.expression) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in @@ -36508,15 +44965,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1017 "src/ocaml/preprocess/parser_raw.mly" +# 1054 "src/ocaml/preprocess/parser_raw.mly" ( mkoperator ~loc:_sloc _1 ) -# 36514 "src/ocaml/preprocess/parser_raw.ml" +# 44971 "src/ocaml/preprocess/parser_raw.ml" in -# 2567 "src/ocaml/preprocess/parser_raw.mly" +# 2679 "src/ocaml/preprocess/parser_raw.mly" ( mkinfix _1 _2 _3 ) -# 36520 "src/ocaml/preprocess/parser_raw.ml" +# 44977 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__3_ in @@ -36524,15 +44981,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 36530 "src/ocaml/preprocess/parser_raw.ml" +# 44987 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 36536 "src/ocaml/preprocess/parser_raw.ml" +# 44993 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36556,23 +45013,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.expression) = let _1 = let _1 = -# 2569 "src/ocaml/preprocess/parser_raw.mly" +# 2681 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_extension _1 ) -# 36562 "src/ocaml/preprocess/parser_raw.ml" +# 45019 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 36570 "src/ocaml/preprocess/parser_raw.ml" +# 45027 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 36576 "src/ocaml/preprocess/parser_raw.ml" +# 45033 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36600,25 +45057,25 @@ module Tables = struct let _startpos = _startpos__1_ in let _loc = (_startpos, _endpos) in -# 2571 "src/ocaml/preprocess/parser_raw.mly" +# 2683 "src/ocaml/preprocess/parser_raw.mly" ( let id = mkrhs Ast_helper.hole_txt _loc in Pexp_extension (id, PStr []) ) -# 36607 "src/ocaml/preprocess/parser_raw.ml" +# 45064 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 36616 "src/ocaml/preprocess/parser_raw.ml" +# 45073 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 36622 "src/ocaml/preprocess/parser_raw.ml" +# 45079 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36666,18 +45123,18 @@ module Tables = struct let _3 = let (_endpos__2_, _startpos__1_, _2, _1) = (_endpos__2_inlined1_, _startpos__1_inlined1_, _2_inlined1, _1_inlined1) in let _1 = -# 2573 "src/ocaml/preprocess/parser_raw.mly" +# 2685 "src/ocaml/preprocess/parser_raw.mly" (Lident "()") -# 36672 "src/ocaml/preprocess/parser_raw.ml" +# 45129 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 36681 "src/ocaml/preprocess/parser_raw.ml" +# 45138 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__3_, _startpos__3_) = (_endpos__2_inlined1_, _startpos__1_inlined1_) in @@ -36687,25 +45144,25 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 36693 "src/ocaml/preprocess/parser_raw.ml" +# 45150 "src/ocaml/preprocess/parser_raw.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1699 "src/ocaml/preprocess/parser_raw.mly" +# 1764 "src/ocaml/preprocess/parser_raw.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 36702 "src/ocaml/preprocess/parser_raw.ml" +# 45159 "src/ocaml/preprocess/parser_raw.ml" in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2574 "src/ocaml/preprocess/parser_raw.mly" +# 2686 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_open(od, mkexp ~loc:(_loc__3_) (Pexp_construct(_3, None))) ) -# 36709 "src/ocaml/preprocess/parser_raw.ml" +# 45166 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__2_inlined1_ in @@ -36713,15 +45170,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 36719 "src/ocaml/preprocess/parser_raw.ml" +# 45176 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 36725 "src/ocaml/preprocess/parser_raw.ml" +# 45182 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36760,25 +45217,25 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Parsetree.expression) = let _1 = let _1 = -# 2580 "src/ocaml/preprocess/parser_raw.mly" +# 2692 "src/ocaml/preprocess/parser_raw.mly" ( let (exten, fields) = _2 in Pexp_record(fields, exten) ) -# 36767 "src/ocaml/preprocess/parser_raw.ml" +# 45224 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 36776 "src/ocaml/preprocess/parser_raw.ml" +# 45233 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 36782 "src/ocaml/preprocess/parser_raw.ml" +# 45239 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36837,27 +45294,27 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 36843 "src/ocaml/preprocess/parser_raw.ml" +# 45300 "src/ocaml/preprocess/parser_raw.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1699 "src/ocaml/preprocess/parser_raw.mly" +# 1764 "src/ocaml/preprocess/parser_raw.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 36852 "src/ocaml/preprocess/parser_raw.ml" +# 45309 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__5_ in -# 2587 "src/ocaml/preprocess/parser_raw.mly" +# 2699 "src/ocaml/preprocess/parser_raw.mly" ( let (exten, fields) = _4 in Pexp_open(od, mkexp ~loc:(_startpos__3_, _endpos) (Pexp_record(fields, exten))) ) -# 36861 "src/ocaml/preprocess/parser_raw.ml" +# 45318 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__5_ in @@ -36865,15 +45322,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 36871 "src/ocaml/preprocess/parser_raw.ml" +# 45328 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 36877 "src/ocaml/preprocess/parser_raw.ml" +# 45334 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36912,14 +45369,14 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _2 = -# 2846 "src/ocaml/preprocess/parser_raw.mly" +# 2986 "src/ocaml/preprocess/parser_raw.mly" ( es ) -# 36918 "src/ocaml/preprocess/parser_raw.ml" +# 45375 "src/ocaml/preprocess/parser_raw.ml" in -# 2595 "src/ocaml/preprocess/parser_raw.mly" +# 2707 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_array(_2) ) -# 36923 "src/ocaml/preprocess/parser_raw.ml" +# 45380 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__3_ in @@ -36927,15 +45384,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 36933 "src/ocaml/preprocess/parser_raw.ml" +# 45390 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 36939 "src/ocaml/preprocess/parser_raw.ml" +# 45396 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -36966,24 +45423,24 @@ module Tables = struct let _endpos = _endpos__2_ in let _v : (Parsetree.expression) = let _1 = let _1 = -# 2601 "src/ocaml/preprocess/parser_raw.mly" +# 2713 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_array [] ) -# 36972 "src/ocaml/preprocess/parser_raw.ml" +# 45429 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 36981 "src/ocaml/preprocess/parser_raw.ml" +# 45438 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 36987 "src/ocaml/preprocess/parser_raw.ml" +# 45444 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37036,9 +45493,9 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _4 = -# 2846 "src/ocaml/preprocess/parser_raw.mly" +# 2986 "src/ocaml/preprocess/parser_raw.mly" ( es ) -# 37042 "src/ocaml/preprocess/parser_raw.ml" +# 45499 "src/ocaml/preprocess/parser_raw.ml" in let od = let _1 = @@ -37046,25 +45503,25 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 37052 "src/ocaml/preprocess/parser_raw.ml" +# 45509 "src/ocaml/preprocess/parser_raw.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1699 "src/ocaml/preprocess/parser_raw.mly" +# 1764 "src/ocaml/preprocess/parser_raw.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 37061 "src/ocaml/preprocess/parser_raw.ml" +# 45518 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__5_ in -# 2603 "src/ocaml/preprocess/parser_raw.mly" +# 2715 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_open(od, mkexp ~loc:(_startpos__3_, _endpos) (Pexp_array(_4))) ) -# 37068 "src/ocaml/preprocess/parser_raw.ml" +# 45525 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__5_ in @@ -37072,15 +45529,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 37078 "src/ocaml/preprocess/parser_raw.ml" +# 45535 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 37084 "src/ocaml/preprocess/parser_raw.ml" +# 45541 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37131,26 +45588,26 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 37137 "src/ocaml/preprocess/parser_raw.ml" +# 45594 "src/ocaml/preprocess/parser_raw.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1699 "src/ocaml/preprocess/parser_raw.mly" +# 1764 "src/ocaml/preprocess/parser_raw.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 37146 "src/ocaml/preprocess/parser_raw.ml" +# 45603 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__4_ in -# 2605 "src/ocaml/preprocess/parser_raw.mly" +# 2717 "src/ocaml/preprocess/parser_raw.mly" ( (* TODO: review the location of Pexp_array *) Pexp_open(od, mkexp ~loc:(_startpos__3_, _endpos) (Pexp_array [])) ) -# 37154 "src/ocaml/preprocess/parser_raw.ml" +# 45611 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__4_ in @@ -37158,15 +45615,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 37164 "src/ocaml/preprocess/parser_raw.ml" +# 45621 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 37170 "src/ocaml/preprocess/parser_raw.ml" +# 45627 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37205,15 +45662,15 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _2 = -# 2846 "src/ocaml/preprocess/parser_raw.mly" +# 2986 "src/ocaml/preprocess/parser_raw.mly" ( es ) -# 37211 "src/ocaml/preprocess/parser_raw.ml" +# 45668 "src/ocaml/preprocess/parser_raw.ml" in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2613 "src/ocaml/preprocess/parser_raw.mly" +# 2725 "src/ocaml/preprocess/parser_raw.mly" ( fst (mktailexp _loc__3_ _2) ) -# 37217 "src/ocaml/preprocess/parser_raw.ml" +# 45674 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__3_ in @@ -37221,15 +45678,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 37227 "src/ocaml/preprocess/parser_raw.ml" +# 45684 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 37233 "src/ocaml/preprocess/parser_raw.ml" +# 45690 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37282,9 +45739,9 @@ module Tables = struct let _v : (Parsetree.expression) = let _1 = let _1 = let _4 = -# 2846 "src/ocaml/preprocess/parser_raw.mly" +# 2986 "src/ocaml/preprocess/parser_raw.mly" ( es ) -# 37288 "src/ocaml/preprocess/parser_raw.ml" +# 45745 "src/ocaml/preprocess/parser_raw.ml" in let od = let _1 = @@ -37292,30 +45749,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 37298 "src/ocaml/preprocess/parser_raw.ml" +# 45755 "src/ocaml/preprocess/parser_raw.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1699 "src/ocaml/preprocess/parser_raw.mly" +# 1764 "src/ocaml/preprocess/parser_raw.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 37307 "src/ocaml/preprocess/parser_raw.ml" +# 45764 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__5_ in let _loc__5_ = (_startpos__5_, _endpos__5_) in -# 2619 "src/ocaml/preprocess/parser_raw.mly" +# 2731 "src/ocaml/preprocess/parser_raw.mly" ( let list_exp = (* TODO: review the location of list_exp *) let tail_exp, _tail_loc = mktailexp _loc__5_ _4 in mkexp ~loc:(_startpos__3_, _endpos) tail_exp in Pexp_open(od, list_exp) ) -# 37319 "src/ocaml/preprocess/parser_raw.ml" +# 45776 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__5_ in @@ -37323,15 +45780,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 37329 "src/ocaml/preprocess/parser_raw.ml" +# 45786 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 37335 "src/ocaml/preprocess/parser_raw.ml" +# 45792 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37379,18 +45836,18 @@ module Tables = struct let _3 = let (_endpos__2_, _startpos__1_, _2, _1) = (_endpos__2_inlined1_, _startpos__1_inlined1_, _2_inlined1, _1_inlined1) in let _1 = -# 2624 "src/ocaml/preprocess/parser_raw.mly" +# 2736 "src/ocaml/preprocess/parser_raw.mly" (Lident "[]") -# 37385 "src/ocaml/preprocess/parser_raw.ml" +# 45842 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 37394 "src/ocaml/preprocess/parser_raw.ml" +# 45851 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__3_, _startpos__3_) = (_endpos__2_inlined1_, _startpos__1_inlined1_) in @@ -37400,25 +45857,25 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 37406 "src/ocaml/preprocess/parser_raw.ml" +# 45863 "src/ocaml/preprocess/parser_raw.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1699 "src/ocaml/preprocess/parser_raw.mly" +# 1764 "src/ocaml/preprocess/parser_raw.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 37415 "src/ocaml/preprocess/parser_raw.ml" +# 45872 "src/ocaml/preprocess/parser_raw.ml" in let _loc__3_ = (_startpos__3_, _endpos__3_) in -# 2625 "src/ocaml/preprocess/parser_raw.mly" +# 2737 "src/ocaml/preprocess/parser_raw.mly" ( Pexp_open(od, mkexp ~loc:_loc__3_ (Pexp_construct(_3, None))) ) -# 37422 "src/ocaml/preprocess/parser_raw.ml" +# 45879 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__2_inlined1_ in @@ -37426,15 +45883,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 37432 "src/ocaml/preprocess/parser_raw.ml" +# 45889 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 37438 "src/ocaml/preprocess/parser_raw.ml" +# 45895 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37527,11 +45984,11 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3611 "src/ocaml/preprocess/parser_raw.mly" +# 3807 "src/ocaml/preprocess/parser_raw.mly" ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in let descr = Ptyp_package (lid, cstrs) in mktyp ~loc:_sloc ~attrs descr ) -# 37535 "src/ocaml/preprocess/parser_raw.ml" +# 45992 "src/ocaml/preprocess/parser_raw.ml" in let _5 = @@ -37539,15 +45996,15 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 37545 "src/ocaml/preprocess/parser_raw.ml" +# 46002 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 37551 "src/ocaml/preprocess/parser_raw.ml" +# 46008 "src/ocaml/preprocess/parser_raw.ml" in let od = @@ -37556,18 +46013,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 37562 "src/ocaml/preprocess/parser_raw.ml" +# 46019 "src/ocaml/preprocess/parser_raw.ml" in let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 1699 "src/ocaml/preprocess/parser_raw.mly" +# 1764 "src/ocaml/preprocess/parser_raw.mly" ( let loc = make_loc _loc__1_ in let me = Mod.ident ~loc _1 in Opn.mk ~loc me ) -# 37571 "src/ocaml/preprocess/parser_raw.ml" +# 46028 "src/ocaml/preprocess/parser_raw.ml" in let _startpos_od_ = _startpos__1_ in @@ -37575,12 +46032,12 @@ module Tables = struct let _symbolstartpos = _startpos_od_ in let _sloc = (_symbolstartpos, _endpos) in -# 2633 "src/ocaml/preprocess/parser_raw.mly" +# 2745 "src/ocaml/preprocess/parser_raw.mly" ( let modexp = mkexp_attrs ~loc:(_startpos__3_, _endpos) (Pexp_constraint (ghexp ~loc:_sloc (Pexp_pack _6), _8)) _5 in Pexp_open(od, modexp) ) -# 37584 "src/ocaml/preprocess/parser_raw.ml" +# 46041 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__9_ in @@ -37588,15 +46045,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1023 "src/ocaml/preprocess/parser_raw.mly" +# 1060 "src/ocaml/preprocess/parser_raw.mly" ( mkexp ~loc:_sloc _1 ) -# 37594 "src/ocaml/preprocess/parser_raw.ml" +# 46051 "src/ocaml/preprocess/parser_raw.ml" in -# 2504 "src/ocaml/preprocess/parser_raw.mly" +# 2616 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 37600 "src/ocaml/preprocess/parser_raw.ml" +# 46057 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37625,30 +46082,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 37631 "src/ocaml/preprocess/parser_raw.ml" +# 46088 "src/ocaml/preprocess/parser_raw.ml" in -# 2929 "src/ocaml/preprocess/parser_raw.mly" +# 3069 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_var (_1) ) -# 37637 "src/ocaml/preprocess/parser_raw.ml" +# 46094 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 37646 "src/ocaml/preprocess/parser_raw.ml" +# 46103 "src/ocaml/preprocess/parser_raw.ml" in -# 2930 "src/ocaml/preprocess/parser_raw.mly" +# 3070 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 37652 "src/ocaml/preprocess/parser_raw.ml" +# 46109 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37671,9 +46128,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = -# 2931 "src/ocaml/preprocess/parser_raw.mly" +# 3071 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 37677 "src/ocaml/preprocess/parser_raw.ml" +# 46134 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37713,9 +46170,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2936 "src/ocaml/preprocess/parser_raw.mly" +# 3076 "src/ocaml/preprocess/parser_raw.mly" ( reloc_pat ~loc:_sloc _2 ) -# 37719 "src/ocaml/preprocess/parser_raw.ml" +# 46176 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37738,9 +46195,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = -# 2938 "src/ocaml/preprocess/parser_raw.mly" +# 3078 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 37744 "src/ocaml/preprocess/parser_raw.ml" +# 46201 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37803,9 +46260,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 37809 "src/ocaml/preprocess/parser_raw.ml" +# 46266 "src/ocaml/preprocess/parser_raw.ml" in let _3 = @@ -37813,24 +46270,24 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 37819 "src/ocaml/preprocess/parser_raw.ml" +# 46276 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 37825 "src/ocaml/preprocess/parser_raw.ml" +# 46282 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2940 "src/ocaml/preprocess/parser_raw.mly" +# 3080 "src/ocaml/preprocess/parser_raw.mly" ( mkpat_attrs ~loc:_sloc (Ppat_unpack _4) _3 ) -# 37834 "src/ocaml/preprocess/parser_raw.ml" +# 46291 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37907,11 +46364,11 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3611 "src/ocaml/preprocess/parser_raw.mly" +# 3807 "src/ocaml/preprocess/parser_raw.mly" ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in let descr = Ptyp_package (lid, cstrs) in mktyp ~loc:_sloc ~attrs descr ) -# 37915 "src/ocaml/preprocess/parser_raw.ml" +# 46372 "src/ocaml/preprocess/parser_raw.ml" in let _4 = @@ -37920,9 +46377,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 37926 "src/ocaml/preprocess/parser_raw.ml" +# 46383 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__4_, _startpos__4_) = (_endpos__1_inlined3_, _startpos__1_inlined3_) in @@ -37931,15 +46388,15 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 37937 "src/ocaml/preprocess/parser_raw.ml" +# 46394 "src/ocaml/preprocess/parser_raw.ml" in -# 4044 "src/ocaml/preprocess/parser_raw.mly" +# 4240 "src/ocaml/preprocess/parser_raw.mly" ( _1, _2 ) -# 37943 "src/ocaml/preprocess/parser_raw.ml" +# 46400 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__7_ in @@ -37947,11 +46404,11 @@ module Tables = struct let _loc__4_ = (_startpos__4_, _endpos__4_) in let _sloc = (_symbolstartpos, _endpos) in -# 2942 "src/ocaml/preprocess/parser_raw.mly" +# 3082 "src/ocaml/preprocess/parser_raw.mly" ( mkpat_attrs ~loc:_sloc (Ppat_constraint(mkpat ~loc:_loc__4_ (Ppat_unpack _4), _6)) _3 ) -# 37955 "src/ocaml/preprocess/parser_raw.ml" +# 46412 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -37975,23 +46432,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2950 "src/ocaml/preprocess/parser_raw.mly" +# 3090 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_any ) -# 37981 "src/ocaml/preprocess/parser_raw.ml" +# 46438 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 37989 "src/ocaml/preprocess/parser_raw.ml" +# 46446 "src/ocaml/preprocess/parser_raw.ml" in -# 2946 "src/ocaml/preprocess/parser_raw.mly" +# 3086 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 37995 "src/ocaml/preprocess/parser_raw.ml" +# 46452 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38015,23 +46472,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2952 "src/ocaml/preprocess/parser_raw.mly" +# 3092 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_constant _1 ) -# 38021 "src/ocaml/preprocess/parser_raw.ml" +# 46478 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 38029 "src/ocaml/preprocess/parser_raw.ml" +# 46486 "src/ocaml/preprocess/parser_raw.ml" in -# 2946 "src/ocaml/preprocess/parser_raw.mly" +# 3086 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 38035 "src/ocaml/preprocess/parser_raw.ml" +# 46492 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38069,24 +46526,24 @@ module Tables = struct let _endpos = _endpos__3_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2954 "src/ocaml/preprocess/parser_raw.mly" +# 3094 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_interval (_1, _3) ) -# 38075 "src/ocaml/preprocess/parser_raw.ml" +# 46532 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__3_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 38084 "src/ocaml/preprocess/parser_raw.ml" +# 46541 "src/ocaml/preprocess/parser_raw.ml" in -# 2946 "src/ocaml/preprocess/parser_raw.mly" +# 3086 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 38090 "src/ocaml/preprocess/parser_raw.ml" +# 46547 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38115,30 +46572,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 38121 "src/ocaml/preprocess/parser_raw.ml" +# 46578 "src/ocaml/preprocess/parser_raw.ml" in -# 2956 "src/ocaml/preprocess/parser_raw.mly" +# 3096 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_construct(_1, None) ) -# 38127 "src/ocaml/preprocess/parser_raw.ml" +# 46584 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 38136 "src/ocaml/preprocess/parser_raw.ml" +# 46593 "src/ocaml/preprocess/parser_raw.ml" in -# 2946 "src/ocaml/preprocess/parser_raw.mly" +# 3086 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 38142 "src/ocaml/preprocess/parser_raw.ml" +# 46599 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38162,23 +46619,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2958 "src/ocaml/preprocess/parser_raw.mly" +# 3098 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_variant(_1, None) ) -# 38168 "src/ocaml/preprocess/parser_raw.ml" +# 46625 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 38176 "src/ocaml/preprocess/parser_raw.ml" +# 46633 "src/ocaml/preprocess/parser_raw.ml" in -# 2946 "src/ocaml/preprocess/parser_raw.mly" +# 3086 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 38182 "src/ocaml/preprocess/parser_raw.ml" +# 46639 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38215,15 +46672,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 38221 "src/ocaml/preprocess/parser_raw.ml" +# 46678 "src/ocaml/preprocess/parser_raw.ml" in -# 2960 "src/ocaml/preprocess/parser_raw.mly" +# 3100 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_type (_2) ) -# 38227 "src/ocaml/preprocess/parser_raw.ml" +# 46684 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -38231,15 +46688,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 38237 "src/ocaml/preprocess/parser_raw.ml" +# 46694 "src/ocaml/preprocess/parser_raw.ml" in -# 2946 "src/ocaml/preprocess/parser_raw.mly" +# 3086 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 38243 "src/ocaml/preprocess/parser_raw.ml" +# 46700 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38282,15 +46739,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 38288 "src/ocaml/preprocess/parser_raw.ml" +# 46745 "src/ocaml/preprocess/parser_raw.ml" in -# 2962 "src/ocaml/preprocess/parser_raw.mly" +# 3102 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_open(_1, _3) ) -# 38294 "src/ocaml/preprocess/parser_raw.ml" +# 46751 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__3_ in @@ -38298,15 +46755,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 38304 "src/ocaml/preprocess/parser_raw.ml" +# 46761 "src/ocaml/preprocess/parser_raw.ml" in -# 2946 "src/ocaml/preprocess/parser_raw.mly" +# 3086 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 38310 "src/ocaml/preprocess/parser_raw.ml" +# 46767 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38354,18 +46811,18 @@ module Tables = struct let _3 = let (_endpos__2_, _startpos__1_, _2, _1) = (_endpos__2_inlined1_, _startpos__1_inlined1_, _2_inlined1, _1_inlined1) in let _1 = -# 2963 "src/ocaml/preprocess/parser_raw.mly" +# 3103 "src/ocaml/preprocess/parser_raw.mly" (Lident "[]") -# 38360 "src/ocaml/preprocess/parser_raw.ml" +# 46817 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 38369 "src/ocaml/preprocess/parser_raw.ml" +# 46826 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__3_ = _endpos__2_inlined1_ in @@ -38374,18 +46831,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 38380 "src/ocaml/preprocess/parser_raw.ml" +# 46837 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__3_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2964 "src/ocaml/preprocess/parser_raw.mly" +# 3104 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_open(_1, mkpat ~loc:_sloc (Ppat_construct(_3, None))) ) -# 38389 "src/ocaml/preprocess/parser_raw.ml" +# 46846 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__2_inlined1_ in @@ -38393,15 +46850,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 38399 "src/ocaml/preprocess/parser_raw.ml" +# 46856 "src/ocaml/preprocess/parser_raw.ml" in -# 2946 "src/ocaml/preprocess/parser_raw.mly" +# 3086 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 38405 "src/ocaml/preprocess/parser_raw.ml" +# 46862 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38449,18 +46906,18 @@ module Tables = struct let _3 = let (_endpos__2_, _startpos__1_, _2, _1) = (_endpos__2_inlined1_, _startpos__1_inlined1_, _2_inlined1, _1_inlined1) in let _1 = -# 2965 "src/ocaml/preprocess/parser_raw.mly" +# 3105 "src/ocaml/preprocess/parser_raw.mly" (Lident "()") -# 38455 "src/ocaml/preprocess/parser_raw.ml" +# 46912 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__2_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 38464 "src/ocaml/preprocess/parser_raw.ml" +# 46921 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__3_ = _endpos__2_inlined1_ in @@ -38469,18 +46926,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 38475 "src/ocaml/preprocess/parser_raw.ml" +# 46932 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__3_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2966 "src/ocaml/preprocess/parser_raw.mly" +# 3106 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_open(_1, mkpat ~loc:_sloc (Ppat_construct(_3, None))) ) -# 38484 "src/ocaml/preprocess/parser_raw.ml" +# 46941 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__2_inlined1_ in @@ -38488,15 +46945,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 38494 "src/ocaml/preprocess/parser_raw.ml" +# 46951 "src/ocaml/preprocess/parser_raw.ml" in -# 2946 "src/ocaml/preprocess/parser_raw.mly" +# 3086 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 38500 "src/ocaml/preprocess/parser_raw.ml" +# 46957 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38553,15 +47010,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 38559 "src/ocaml/preprocess/parser_raw.ml" +# 47016 "src/ocaml/preprocess/parser_raw.ml" in -# 2968 "src/ocaml/preprocess/parser_raw.mly" +# 3108 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_open (_1, _4) ) -# 38565 "src/ocaml/preprocess/parser_raw.ml" +# 47022 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__5_ in @@ -38569,15 +47026,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 38575 "src/ocaml/preprocess/parser_raw.ml" +# 47032 "src/ocaml/preprocess/parser_raw.ml" in -# 2946 "src/ocaml/preprocess/parser_raw.mly" +# 3086 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 38581 "src/ocaml/preprocess/parser_raw.ml" +# 47038 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38629,24 +47086,24 @@ module Tables = struct let _endpos = _endpos__5_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2978 "src/ocaml/preprocess/parser_raw.mly" +# 3118 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_constraint(_2, _4) ) -# 38635 "src/ocaml/preprocess/parser_raw.ml" +# 47092 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__5_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 38644 "src/ocaml/preprocess/parser_raw.ml" +# 47101 "src/ocaml/preprocess/parser_raw.ml" in -# 2946 "src/ocaml/preprocess/parser_raw.mly" +# 3086 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 38650 "src/ocaml/preprocess/parser_raw.ml" +# 47107 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38670,23 +47127,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.pattern) = let _1 = let _1 = -# 2989 "src/ocaml/preprocess/parser_raw.mly" +# 3129 "src/ocaml/preprocess/parser_raw.mly" ( Ppat_extension _1 ) -# 38676 "src/ocaml/preprocess/parser_raw.ml" +# 47133 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1025 "src/ocaml/preprocess/parser_raw.mly" +# 1062 "src/ocaml/preprocess/parser_raw.mly" ( mkpat ~loc:_sloc _1 ) -# 38684 "src/ocaml/preprocess/parser_raw.ml" +# 47141 "src/ocaml/preprocess/parser_raw.ml" in -# 2946 "src/ocaml/preprocess/parser_raw.mly" +# 3086 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 38690 "src/ocaml/preprocess/parser_raw.ml" +# 47147 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38705,17 +47162,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 38711 "src/ocaml/preprocess/parser_raw.ml" +# 47168 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3952 "src/ocaml/preprocess/parser_raw.mly" +# 4148 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 38719 "src/ocaml/preprocess/parser_raw.ml" +# 47176 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38734,17 +47191,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 845 "src/ocaml/preprocess/parser_raw.mly" +# 890 "src/ocaml/preprocess/parser_raw.mly" (string) -# 38740 "src/ocaml/preprocess/parser_raw.ml" +# 47197 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3953 "src/ocaml/preprocess/parser_raw.mly" +# 4149 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 38748 "src/ocaml/preprocess/parser_raw.ml" +# 47205 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38767,9 +47224,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3954 "src/ocaml/preprocess/parser_raw.mly" +# 4150 "src/ocaml/preprocess/parser_raw.mly" ( "and" ) -# 38773 "src/ocaml/preprocess/parser_raw.ml" +# 47230 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38792,9 +47249,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3955 "src/ocaml/preprocess/parser_raw.mly" +# 4151 "src/ocaml/preprocess/parser_raw.mly" ( "as" ) -# 38798 "src/ocaml/preprocess/parser_raw.ml" +# 47255 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38817,9 +47274,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3956 "src/ocaml/preprocess/parser_raw.mly" +# 4152 "src/ocaml/preprocess/parser_raw.mly" ( "assert" ) -# 38823 "src/ocaml/preprocess/parser_raw.ml" +# 47280 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38842,9 +47299,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3957 "src/ocaml/preprocess/parser_raw.mly" +# 4153 "src/ocaml/preprocess/parser_raw.mly" ( "begin" ) -# 38848 "src/ocaml/preprocess/parser_raw.ml" +# 47305 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38867,9 +47324,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3958 "src/ocaml/preprocess/parser_raw.mly" +# 4154 "src/ocaml/preprocess/parser_raw.mly" ( "class" ) -# 38873 "src/ocaml/preprocess/parser_raw.ml" +# 47330 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38892,9 +47349,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3959 "src/ocaml/preprocess/parser_raw.mly" +# 4155 "src/ocaml/preprocess/parser_raw.mly" ( "constraint" ) -# 38898 "src/ocaml/preprocess/parser_raw.ml" +# 47355 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38917,9 +47374,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3960 "src/ocaml/preprocess/parser_raw.mly" +# 4156 "src/ocaml/preprocess/parser_raw.mly" ( "do" ) -# 38923 "src/ocaml/preprocess/parser_raw.ml" +# 47380 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38942,9 +47399,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3961 "src/ocaml/preprocess/parser_raw.mly" +# 4157 "src/ocaml/preprocess/parser_raw.mly" ( "done" ) -# 38948 "src/ocaml/preprocess/parser_raw.ml" +# 47405 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38967,9 +47424,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3962 "src/ocaml/preprocess/parser_raw.mly" +# 4158 "src/ocaml/preprocess/parser_raw.mly" ( "downto" ) -# 38973 "src/ocaml/preprocess/parser_raw.ml" +# 47430 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -38992,9 +47449,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3963 "src/ocaml/preprocess/parser_raw.mly" +# 4159 "src/ocaml/preprocess/parser_raw.mly" ( "else" ) -# 38998 "src/ocaml/preprocess/parser_raw.ml" +# 47455 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39017,9 +47474,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3964 "src/ocaml/preprocess/parser_raw.mly" +# 4160 "src/ocaml/preprocess/parser_raw.mly" ( "end" ) -# 39023 "src/ocaml/preprocess/parser_raw.ml" +# 47480 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39042,9 +47499,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3965 "src/ocaml/preprocess/parser_raw.mly" +# 4161 "src/ocaml/preprocess/parser_raw.mly" ( "exception" ) -# 39048 "src/ocaml/preprocess/parser_raw.ml" +# 47505 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39067,9 +47524,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3966 "src/ocaml/preprocess/parser_raw.mly" +# 4162 "src/ocaml/preprocess/parser_raw.mly" ( "external" ) -# 39073 "src/ocaml/preprocess/parser_raw.ml" +# 47530 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39092,9 +47549,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3967 "src/ocaml/preprocess/parser_raw.mly" +# 4163 "src/ocaml/preprocess/parser_raw.mly" ( "false" ) -# 39098 "src/ocaml/preprocess/parser_raw.ml" +# 47555 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39117,9 +47574,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3968 "src/ocaml/preprocess/parser_raw.mly" +# 4164 "src/ocaml/preprocess/parser_raw.mly" ( "for" ) -# 39123 "src/ocaml/preprocess/parser_raw.ml" +# 47580 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39142,9 +47599,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3969 "src/ocaml/preprocess/parser_raw.mly" +# 4165 "src/ocaml/preprocess/parser_raw.mly" ( "fun" ) -# 39148 "src/ocaml/preprocess/parser_raw.ml" +# 47605 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39167,9 +47624,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3970 "src/ocaml/preprocess/parser_raw.mly" +# 4166 "src/ocaml/preprocess/parser_raw.mly" ( "function" ) -# 39173 "src/ocaml/preprocess/parser_raw.ml" +# 47630 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39192,9 +47649,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3971 "src/ocaml/preprocess/parser_raw.mly" +# 4167 "src/ocaml/preprocess/parser_raw.mly" ( "functor" ) -# 39198 "src/ocaml/preprocess/parser_raw.ml" +# 47655 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39217,9 +47674,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3972 "src/ocaml/preprocess/parser_raw.mly" +# 4168 "src/ocaml/preprocess/parser_raw.mly" ( "if" ) -# 39223 "src/ocaml/preprocess/parser_raw.ml" +# 47680 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39242,9 +47699,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3973 "src/ocaml/preprocess/parser_raw.mly" +# 4169 "src/ocaml/preprocess/parser_raw.mly" ( "in" ) -# 39248 "src/ocaml/preprocess/parser_raw.ml" +# 47705 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39267,9 +47724,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3974 "src/ocaml/preprocess/parser_raw.mly" +# 4170 "src/ocaml/preprocess/parser_raw.mly" ( "include" ) -# 39273 "src/ocaml/preprocess/parser_raw.ml" +# 47730 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39292,9 +47749,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3975 "src/ocaml/preprocess/parser_raw.mly" +# 4171 "src/ocaml/preprocess/parser_raw.mly" ( "inherit" ) -# 39298 "src/ocaml/preprocess/parser_raw.ml" +# 47755 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39317,9 +47774,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3976 "src/ocaml/preprocess/parser_raw.mly" +# 4172 "src/ocaml/preprocess/parser_raw.mly" ( "initializer" ) -# 39323 "src/ocaml/preprocess/parser_raw.ml" +# 47780 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39342,9 +47799,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3977 "src/ocaml/preprocess/parser_raw.mly" +# 4173 "src/ocaml/preprocess/parser_raw.mly" ( "lazy" ) -# 39348 "src/ocaml/preprocess/parser_raw.ml" +# 47805 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39367,9 +47824,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3978 "src/ocaml/preprocess/parser_raw.mly" +# 4174 "src/ocaml/preprocess/parser_raw.mly" ( "let" ) -# 39373 "src/ocaml/preprocess/parser_raw.ml" +# 47830 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39392,9 +47849,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3979 "src/ocaml/preprocess/parser_raw.mly" +# 4175 "src/ocaml/preprocess/parser_raw.mly" ( "match" ) -# 39398 "src/ocaml/preprocess/parser_raw.ml" +# 47855 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39417,9 +47874,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3980 "src/ocaml/preprocess/parser_raw.mly" +# 4176 "src/ocaml/preprocess/parser_raw.mly" ( "method" ) -# 39423 "src/ocaml/preprocess/parser_raw.ml" +# 47880 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39442,9 +47899,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3981 "src/ocaml/preprocess/parser_raw.mly" +# 4177 "src/ocaml/preprocess/parser_raw.mly" ( "module" ) -# 39448 "src/ocaml/preprocess/parser_raw.ml" +# 47905 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39467,9 +47924,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3982 "src/ocaml/preprocess/parser_raw.mly" +# 4178 "src/ocaml/preprocess/parser_raw.mly" ( "mutable" ) -# 39473 "src/ocaml/preprocess/parser_raw.ml" +# 47930 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39492,9 +47949,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3983 "src/ocaml/preprocess/parser_raw.mly" +# 4179 "src/ocaml/preprocess/parser_raw.mly" ( "new" ) -# 39498 "src/ocaml/preprocess/parser_raw.ml" +# 47955 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39517,9 +47974,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3984 "src/ocaml/preprocess/parser_raw.mly" +# 4180 "src/ocaml/preprocess/parser_raw.mly" ( "nonrec" ) -# 39523 "src/ocaml/preprocess/parser_raw.ml" +# 47980 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39542,9 +47999,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3985 "src/ocaml/preprocess/parser_raw.mly" +# 4181 "src/ocaml/preprocess/parser_raw.mly" ( "object" ) -# 39548 "src/ocaml/preprocess/parser_raw.ml" +# 48005 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39567,9 +48024,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3986 "src/ocaml/preprocess/parser_raw.mly" +# 4182 "src/ocaml/preprocess/parser_raw.mly" ( "of" ) -# 39573 "src/ocaml/preprocess/parser_raw.ml" +# 48030 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39592,9 +48049,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3987 "src/ocaml/preprocess/parser_raw.mly" +# 4183 "src/ocaml/preprocess/parser_raw.mly" ( "open" ) -# 39598 "src/ocaml/preprocess/parser_raw.ml" +# 48055 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39617,9 +48074,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3988 "src/ocaml/preprocess/parser_raw.mly" +# 4184 "src/ocaml/preprocess/parser_raw.mly" ( "or" ) -# 39623 "src/ocaml/preprocess/parser_raw.ml" +# 48080 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39642,9 +48099,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3989 "src/ocaml/preprocess/parser_raw.mly" +# 4185 "src/ocaml/preprocess/parser_raw.mly" ( "private" ) -# 39648 "src/ocaml/preprocess/parser_raw.ml" +# 48105 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39667,9 +48124,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3990 "src/ocaml/preprocess/parser_raw.mly" +# 4186 "src/ocaml/preprocess/parser_raw.mly" ( "rec" ) -# 39673 "src/ocaml/preprocess/parser_raw.ml" +# 48130 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39692,9 +48149,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3991 "src/ocaml/preprocess/parser_raw.mly" +# 4187 "src/ocaml/preprocess/parser_raw.mly" ( "sig" ) -# 39698 "src/ocaml/preprocess/parser_raw.ml" +# 48155 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39717,9 +48174,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3992 "src/ocaml/preprocess/parser_raw.mly" +# 4188 "src/ocaml/preprocess/parser_raw.mly" ( "struct" ) -# 39723 "src/ocaml/preprocess/parser_raw.ml" +# 48180 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39742,9 +48199,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3993 "src/ocaml/preprocess/parser_raw.mly" +# 4189 "src/ocaml/preprocess/parser_raw.mly" ( "then" ) -# 39748 "src/ocaml/preprocess/parser_raw.ml" +# 48205 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39767,9 +48224,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3994 "src/ocaml/preprocess/parser_raw.mly" +# 4190 "src/ocaml/preprocess/parser_raw.mly" ( "to" ) -# 39773 "src/ocaml/preprocess/parser_raw.ml" +# 48230 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39792,9 +48249,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3995 "src/ocaml/preprocess/parser_raw.mly" +# 4191 "src/ocaml/preprocess/parser_raw.mly" ( "true" ) -# 39798 "src/ocaml/preprocess/parser_raw.ml" +# 48255 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39817,9 +48274,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3996 "src/ocaml/preprocess/parser_raw.mly" +# 4192 "src/ocaml/preprocess/parser_raw.mly" ( "try" ) -# 39823 "src/ocaml/preprocess/parser_raw.ml" +# 48280 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39842,9 +48299,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3997 "src/ocaml/preprocess/parser_raw.mly" +# 4193 "src/ocaml/preprocess/parser_raw.mly" ( "type" ) -# 39848 "src/ocaml/preprocess/parser_raw.ml" +# 48305 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39867,9 +48324,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3998 "src/ocaml/preprocess/parser_raw.mly" +# 4194 "src/ocaml/preprocess/parser_raw.mly" ( "val" ) -# 39873 "src/ocaml/preprocess/parser_raw.ml" +# 48330 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39892,9 +48349,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3999 "src/ocaml/preprocess/parser_raw.mly" +# 4195 "src/ocaml/preprocess/parser_raw.mly" ( "virtual" ) -# 39898 "src/ocaml/preprocess/parser_raw.ml" +# 48355 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39917,9 +48374,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 4000 "src/ocaml/preprocess/parser_raw.mly" +# 4196 "src/ocaml/preprocess/parser_raw.mly" ( "when" ) -# 39923 "src/ocaml/preprocess/parser_raw.ml" +# 48380 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39942,9 +48399,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 4001 "src/ocaml/preprocess/parser_raw.mly" +# 4197 "src/ocaml/preprocess/parser_raw.mly" ( "while" ) -# 39948 "src/ocaml/preprocess/parser_raw.ml" +# 48405 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39967,9 +48424,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 4002 "src/ocaml/preprocess/parser_raw.mly" +# 4198 "src/ocaml/preprocess/parser_raw.mly" ( "with" ) -# 39973 "src/ocaml/preprocess/parser_raw.ml" +# 48430 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -39992,9 +48449,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.type_exception * string Location.loc option) = -# 3270 "src/ocaml/preprocess/parser_raw.mly" +# 3410 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 39998 "src/ocaml/preprocess/parser_raw.ml" +# 48455 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40068,18 +48525,18 @@ module Tables = struct let _v : (Parsetree.type_exception * string Location.loc option) = let attrs = let _1 = _1_inlined5 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40074 "src/ocaml/preprocess/parser_raw.ml" +# 48531 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs_ = _endpos__1_inlined5_ in let attrs2 = let _1 = _1_inlined4 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40083 "src/ocaml/preprocess/parser_raw.ml" +# 48540 "src/ocaml/preprocess/parser_raw.ml" in let lid = @@ -40088,9 +48545,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 40094 "src/ocaml/preprocess/parser_raw.ml" +# 48551 "src/ocaml/preprocess/parser_raw.ml" in let id = @@ -40099,62 +48556,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 40105 "src/ocaml/preprocess/parser_raw.ml" +# 48562 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40113 "src/ocaml/preprocess/parser_raw.ml" +# 48570 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3279 "src/ocaml/preprocess/parser_raw.mly" +# 3419 "src/ocaml/preprocess/parser_raw.mly" ( let loc = make_loc _sloc in let docs = symbol_docs _sloc in Te.mk_exception ~attrs (Te.rebind id lid ~attrs:(attrs1 @ attrs2) ~loc ~docs) , ext ) -# 40126 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - } = _menhir_stack in - let _2 : (Parsetree.expression) = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__2_ in - let _v : (Parsetree.expression) = -# 2770 "src/ocaml/preprocess/parser_raw.mly" - ( _2 ) -# 40158 "src/ocaml/preprocess/parser_raw.ml" +# 48583 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40179,17 +48604,14 @@ module Tables = struct }; } = _menhir_stack in let _2 : (Parsetree.expression) = Obj.magic _2 in - let _1 : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = Obj.magic _1 in + let _1 : unit = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in - let _v : (Parsetree.expression) = let _endpos = _endpos__2_ in - let _symbolstartpos = _startpos__1_ in - let _sloc = (_symbolstartpos, _endpos) in - -# 2772 "src/ocaml/preprocess/parser_raw.mly" - ( let (l, o, p) = _1 in ghexp ~loc:_sloc (Pexp_fun(l, o, p, _2)) ) -# 40193 "src/ocaml/preprocess/parser_raw.ml" + let _v : (Parsetree.expression) = +# 2872 "src/ocaml/preprocess/parser_raw.mly" + ( _2 ) +# 48615 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40202,55 +48624,44 @@ module Tables = struct let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = xs; - MenhirLib.EngineTypes.startp = _startpos_xs_; - MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _; - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; }; }; } = _menhir_stack in - let _5 : (Parsetree.expression) = Obj.magic _5 in - let _4 : unit = Obj.magic _4 in - let xs : (string Location.loc list) = Obj.magic xs in - let _2 : unit = Obj.magic _2 in - let _1 : unit = Obj.magic _1 in + let _4 : (Parsetree.function_body) = Obj.magic _4 in + let _3 : unit = Obj.magic _3 in + let _2 : (Parsetree.type_constraint option) = Obj.magic _2 in + let _1 : (Parsetree.function_param list) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in - let _endpos = _endpos__5_ in - let _v : (Parsetree.expression) = let _3 = -# 2662 "src/ocaml/preprocess/parser_raw.mly" - ( xs ) -# 40246 "src/ocaml/preprocess/parser_raw.ml" - in - let _endpos = _endpos__5_ in + let _endpos = _endpos__4_ in + let _v : (Parsetree.expression) = let _endpos = _endpos__4_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 2774 "src/ocaml/preprocess/parser_raw.mly" - ( mk_newtypes ~loc:_sloc _3 _5 ) -# 40254 "src/ocaml/preprocess/parser_raw.ml" +# 2874 "src/ocaml/preprocess/parser_raw.mly" + ( ghexp ~loc:_sloc (mkfunction _1 _2 _4) + ) +# 48665 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40277,39 +48688,39 @@ module Tables = struct let ys = # 260 "" ( List.flatten xss ) -# 40281 "src/ocaml/preprocess/parser_raw.ml" +# 48692 "src/ocaml/preprocess/parser_raw.ml" in let xs = let items = -# 1060 "src/ocaml/preprocess/parser_raw.mly" +# 1097 "src/ocaml/preprocess/parser_raw.mly" ( [] ) -# 40287 "src/ocaml/preprocess/parser_raw.ml" +# 48698 "src/ocaml/preprocess/parser_raw.ml" in -# 1502 "src/ocaml/preprocess/parser_raw.mly" +# 1563 "src/ocaml/preprocess/parser_raw.mly" ( items ) -# 40292 "src/ocaml/preprocess/parser_raw.ml" +# 48703 "src/ocaml/preprocess/parser_raw.ml" in # 267 "" ( xs @ ys ) -# 40298 "src/ocaml/preprocess/parser_raw.ml" +# 48709 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 982 "src/ocaml/preprocess/parser_raw.mly" +# 1019 "src/ocaml/preprocess/parser_raw.mly" ( extra_str _startpos _endpos _1 ) -# 40307 "src/ocaml/preprocess/parser_raw.ml" +# 48718 "src/ocaml/preprocess/parser_raw.ml" in -# 1495 "src/ocaml/preprocess/parser_raw.mly" +# 1556 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40313 "src/ocaml/preprocess/parser_raw.ml" +# 48724 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40350,7 +48761,7 @@ module Tables = struct let ys = # 260 "" ( List.flatten xss ) -# 40354 "src/ocaml/preprocess/parser_raw.ml" +# 48765 "src/ocaml/preprocess/parser_raw.ml" in let xs = let items = @@ -40358,93 +48769,65 @@ module Tables = struct let _1 = let _1 = let attrs = -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40364 "src/ocaml/preprocess/parser_raw.ml" +# 48775 "src/ocaml/preprocess/parser_raw.ml" in -# 1509 "src/ocaml/preprocess/parser_raw.mly" +# 1570 "src/ocaml/preprocess/parser_raw.mly" ( mkstrexp e attrs ) -# 40369 "src/ocaml/preprocess/parser_raw.ml" +# 48780 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__1_ = _startpos_e_ in let _startpos = _startpos__1_ in -# 994 "src/ocaml/preprocess/parser_raw.mly" +# 1031 "src/ocaml/preprocess/parser_raw.mly" ( text_str _startpos @ [_1] ) -# 40377 "src/ocaml/preprocess/parser_raw.ml" +# 48788 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__1_ = _startpos_e_ in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 1013 "src/ocaml/preprocess/parser_raw.mly" +# 1050 "src/ocaml/preprocess/parser_raw.mly" ( mark_rhs_docs _startpos _endpos; _1 ) -# 40387 "src/ocaml/preprocess/parser_raw.ml" +# 48798 "src/ocaml/preprocess/parser_raw.ml" in -# 1062 "src/ocaml/preprocess/parser_raw.mly" +# 1099 "src/ocaml/preprocess/parser_raw.mly" ( x ) -# 40393 "src/ocaml/preprocess/parser_raw.ml" +# 48804 "src/ocaml/preprocess/parser_raw.ml" in -# 1502 "src/ocaml/preprocess/parser_raw.mly" +# 1563 "src/ocaml/preprocess/parser_raw.mly" ( items ) -# 40399 "src/ocaml/preprocess/parser_raw.ml" +# 48810 "src/ocaml/preprocess/parser_raw.ml" in # 267 "" ( xs @ ys ) -# 40405 "src/ocaml/preprocess/parser_raw.ml" +# 48816 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_e_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 982 "src/ocaml/preprocess/parser_raw.mly" +# 1019 "src/ocaml/preprocess/parser_raw.mly" ( extra_str _startpos _endpos _1 ) -# 40414 "src/ocaml/preprocess/parser_raw.ml" +# 48825 "src/ocaml/preprocess/parser_raw.ml" in -# 1495 "src/ocaml/preprocess/parser_raw.mly" +# 1556 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40420 "src/ocaml/preprocess/parser_raw.ml" - in - { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = Obj.repr _v; - MenhirLib.EngineTypes.startp = _startpos; - MenhirLib.EngineTypes.endp = _endpos; - MenhirLib.EngineTypes.next = _menhir_stack; - }); - (fun _menhir_env -> - let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in - let { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - } = _menhir_stack in - let _1 : (Ast_helper.let_bindings) = Obj.magic _1 in - let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in - let _startpos = _startpos__1_ in - let _endpos = _endpos__1_ in - let _v : (Parsetree.structure_item) = let _endpos = _endpos__1_ in - let _startpos = _startpos__1_ in - let _loc = (_startpos, _endpos) in - -# 4074 "src/ocaml/preprocess/parser_raw.mly" - ( val_of_lwt_bindings ~loc:_loc _1 ) -# 40448 "src/ocaml/preprocess/parser_raw.ml" +# 48831 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40470,9 +48853,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1524 "src/ocaml/preprocess/parser_raw.mly" +# 1585 "src/ocaml/preprocess/parser_raw.mly" ( val_of_let_bindings ~loc:_sloc _1 ) -# 40476 "src/ocaml/preprocess/parser_raw.ml" +# 48859 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40506,9 +48889,9 @@ module Tables = struct let _2 = let _1 = _1_inlined1 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40512 "src/ocaml/preprocess/parser_raw.ml" +# 48895 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__2_ = _endpos__1_inlined1_ in @@ -40516,10 +48899,10 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1527 "src/ocaml/preprocess/parser_raw.mly" +# 1588 "src/ocaml/preprocess/parser_raw.mly" ( let docs = symbol_docs _sloc in Pstr_extension (_1, add_docs_attrs docs _2) ) -# 40523 "src/ocaml/preprocess/parser_raw.ml" +# 48906 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined1_ in @@ -40527,15 +48910,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1029 "src/ocaml/preprocess/parser_raw.mly" +# 1066 "src/ocaml/preprocess/parser_raw.mly" ( mkstr ~loc:_sloc _1 ) -# 40533 "src/ocaml/preprocess/parser_raw.ml" +# 48916 "src/ocaml/preprocess/parser_raw.ml" in -# 1558 "src/ocaml/preprocess/parser_raw.mly" +# 1619 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40539 "src/ocaml/preprocess/parser_raw.ml" +# 48922 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40559,23 +48942,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.structure_item) = let _1 = let _1 = -# 1530 "src/ocaml/preprocess/parser_raw.mly" +# 1591 "src/ocaml/preprocess/parser_raw.mly" ( Pstr_attribute _1 ) -# 40565 "src/ocaml/preprocess/parser_raw.ml" +# 48948 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1029 "src/ocaml/preprocess/parser_raw.mly" +# 1066 "src/ocaml/preprocess/parser_raw.mly" ( mkstr ~loc:_sloc _1 ) -# 40573 "src/ocaml/preprocess/parser_raw.ml" +# 48956 "src/ocaml/preprocess/parser_raw.ml" in -# 1558 "src/ocaml/preprocess/parser_raw.mly" +# 1619 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40579 "src/ocaml/preprocess/parser_raw.ml" +# 48962 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40599,23 +48982,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.structure_item) = let _1 = let _1 = -# 1534 "src/ocaml/preprocess/parser_raw.mly" +# 1595 "src/ocaml/preprocess/parser_raw.mly" ( pstr_primitive _1 ) -# 40605 "src/ocaml/preprocess/parser_raw.ml" +# 48988 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1046 "src/ocaml/preprocess/parser_raw.mly" +# 1083 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 40613 "src/ocaml/preprocess/parser_raw.ml" +# 48996 "src/ocaml/preprocess/parser_raw.ml" in -# 1558 "src/ocaml/preprocess/parser_raw.mly" +# 1619 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40619 "src/ocaml/preprocess/parser_raw.ml" +# 49002 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40639,23 +49022,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.structure_item) = let _1 = let _1 = -# 1536 "src/ocaml/preprocess/parser_raw.mly" +# 1597 "src/ocaml/preprocess/parser_raw.mly" ( pstr_primitive _1 ) -# 40645 "src/ocaml/preprocess/parser_raw.ml" +# 49028 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1046 "src/ocaml/preprocess/parser_raw.mly" +# 1083 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 40653 "src/ocaml/preprocess/parser_raw.ml" +# 49036 "src/ocaml/preprocess/parser_raw.ml" in -# 1558 "src/ocaml/preprocess/parser_raw.mly" +# 1619 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40659 "src/ocaml/preprocess/parser_raw.ml" +# 49042 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40690,26 +49073,26 @@ module Tables = struct let _1 = let _1 = let _1 = -# 1221 "src/ocaml/preprocess/parser_raw.mly" +# 1279 "src/ocaml/preprocess/parser_raw.mly" ( let (x, b) = a in x, b :: bs ) -# 40696 "src/ocaml/preprocess/parser_raw.ml" +# 49079 "src/ocaml/preprocess/parser_raw.ml" in -# 3112 "src/ocaml/preprocess/parser_raw.mly" +# 3252 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40701 "src/ocaml/preprocess/parser_raw.ml" +# 49084 "src/ocaml/preprocess/parser_raw.ml" in -# 3095 "src/ocaml/preprocess/parser_raw.mly" +# 3235 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40707 "src/ocaml/preprocess/parser_raw.ml" +# 49090 "src/ocaml/preprocess/parser_raw.ml" in -# 1538 "src/ocaml/preprocess/parser_raw.mly" +# 1599 "src/ocaml/preprocess/parser_raw.mly" ( pstr_type _1 ) -# 40713 "src/ocaml/preprocess/parser_raw.ml" +# 49096 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_bs_, _startpos_a_) in @@ -40717,15 +49100,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1046 "src/ocaml/preprocess/parser_raw.mly" +# 1083 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 40723 "src/ocaml/preprocess/parser_raw.ml" +# 49106 "src/ocaml/preprocess/parser_raw.ml" in -# 1558 "src/ocaml/preprocess/parser_raw.mly" +# 1619 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40729 "src/ocaml/preprocess/parser_raw.ml" +# 49112 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40810,16 +49193,16 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40816 "src/ocaml/preprocess/parser_raw.ml" +# 49199 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in let cs = -# 1213 "src/ocaml/preprocess/parser_raw.mly" +# 1271 "src/ocaml/preprocess/parser_raw.mly" ( List.rev xs ) -# 40823 "src/ocaml/preprocess/parser_raw.ml" +# 49206 "src/ocaml/preprocess/parser_raw.ml" in let tid = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in @@ -40827,46 +49210,46 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 40833 "src/ocaml/preprocess/parser_raw.ml" +# 49216 "src/ocaml/preprocess/parser_raw.ml" in let _4 = -# 3872 "src/ocaml/preprocess/parser_raw.mly" +# 4068 "src/ocaml/preprocess/parser_raw.mly" ( Recursive ) -# 40839 "src/ocaml/preprocess/parser_raw.ml" +# 49222 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40846 "src/ocaml/preprocess/parser_raw.ml" +# 49229 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3367 "src/ocaml/preprocess/parser_raw.mly" +# 3507 "src/ocaml/preprocess/parser_raw.mly" ( let docs = symbol_docs _sloc in let attrs = attrs1 @ attrs2 in Te.mk tid cs ~params ~priv ~attrs ~docs, ext ) -# 40858 "src/ocaml/preprocess/parser_raw.ml" +# 49241 "src/ocaml/preprocess/parser_raw.ml" in -# 3350 "src/ocaml/preprocess/parser_raw.mly" +# 3490 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40864 "src/ocaml/preprocess/parser_raw.ml" +# 49247 "src/ocaml/preprocess/parser_raw.ml" in -# 1540 "src/ocaml/preprocess/parser_raw.mly" +# 1601 "src/ocaml/preprocess/parser_raw.mly" ( pstr_typext _1 ) -# 40870 "src/ocaml/preprocess/parser_raw.ml" +# 49253 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined3_ in @@ -40874,15 +49257,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1046 "src/ocaml/preprocess/parser_raw.mly" +# 1083 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 40880 "src/ocaml/preprocess/parser_raw.ml" +# 49263 "src/ocaml/preprocess/parser_raw.ml" in -# 1558 "src/ocaml/preprocess/parser_raw.mly" +# 1619 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40886 "src/ocaml/preprocess/parser_raw.ml" +# 49269 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -40974,16 +49357,16 @@ module Tables = struct let attrs2 = let _1 = _1_inlined4 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 40980 "src/ocaml/preprocess/parser_raw.ml" +# 49363 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined4_ in let cs = -# 1213 "src/ocaml/preprocess/parser_raw.mly" +# 1271 "src/ocaml/preprocess/parser_raw.mly" ( List.rev xs ) -# 40987 "src/ocaml/preprocess/parser_raw.ml" +# 49370 "src/ocaml/preprocess/parser_raw.ml" in let tid = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in @@ -40991,9 +49374,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 40997 "src/ocaml/preprocess/parser_raw.ml" +# 49380 "src/ocaml/preprocess/parser_raw.ml" in let _4 = @@ -41002,41 +49385,41 @@ module Tables = struct let _startpos = _startpos__1_ in let _loc = (_startpos, _endpos) in -# 3874 "src/ocaml/preprocess/parser_raw.mly" +# 4070 "src/ocaml/preprocess/parser_raw.mly" ( not_expecting _loc "nonrec flag"; Recursive ) -# 41008 "src/ocaml/preprocess/parser_raw.ml" +# 49391 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41016 "src/ocaml/preprocess/parser_raw.ml" +# 49399 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3367 "src/ocaml/preprocess/parser_raw.mly" +# 3507 "src/ocaml/preprocess/parser_raw.mly" ( let docs = symbol_docs _sloc in let attrs = attrs1 @ attrs2 in Te.mk tid cs ~params ~priv ~attrs ~docs, ext ) -# 41028 "src/ocaml/preprocess/parser_raw.ml" +# 49411 "src/ocaml/preprocess/parser_raw.ml" in -# 3350 "src/ocaml/preprocess/parser_raw.mly" +# 3490 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41034 "src/ocaml/preprocess/parser_raw.ml" +# 49417 "src/ocaml/preprocess/parser_raw.ml" in -# 1540 "src/ocaml/preprocess/parser_raw.mly" +# 1601 "src/ocaml/preprocess/parser_raw.mly" ( pstr_typext _1 ) -# 41040 "src/ocaml/preprocess/parser_raw.ml" +# 49423 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined4_ in @@ -41044,15 +49427,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1046 "src/ocaml/preprocess/parser_raw.mly" +# 1083 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 41050 "src/ocaml/preprocess/parser_raw.ml" +# 49433 "src/ocaml/preprocess/parser_raw.ml" in -# 1558 "src/ocaml/preprocess/parser_raw.mly" +# 1619 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41056 "src/ocaml/preprocess/parser_raw.ml" +# 49439 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41076,23 +49459,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.structure_item) = let _1 = let _1 = -# 1542 "src/ocaml/preprocess/parser_raw.mly" +# 1603 "src/ocaml/preprocess/parser_raw.mly" ( pstr_exception _1 ) -# 41082 "src/ocaml/preprocess/parser_raw.ml" +# 49465 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1046 "src/ocaml/preprocess/parser_raw.mly" +# 1083 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 41090 "src/ocaml/preprocess/parser_raw.ml" +# 49473 "src/ocaml/preprocess/parser_raw.ml" in -# 1558 "src/ocaml/preprocess/parser_raw.mly" +# 1619 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41096 "src/ocaml/preprocess/parser_raw.ml" +# 49479 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41155,9 +49538,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41161 "src/ocaml/preprocess/parser_raw.ml" +# 49544 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -41167,36 +49550,36 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 41173 "src/ocaml/preprocess/parser_raw.ml" +# 49556 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41181 "src/ocaml/preprocess/parser_raw.ml" +# 49564 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1568 "src/ocaml/preprocess/parser_raw.mly" +# 1629 "src/ocaml/preprocess/parser_raw.mly" ( let docs = symbol_docs _sloc in let loc = make_loc _sloc in let attrs = attrs1 @ attrs2 in let body = Mb.mk name body ~attrs ~loc ~docs in Pstr_module body, ext ) -# 41194 "src/ocaml/preprocess/parser_raw.ml" +# 49577 "src/ocaml/preprocess/parser_raw.ml" in -# 1544 "src/ocaml/preprocess/parser_raw.mly" +# 1605 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41200 "src/ocaml/preprocess/parser_raw.ml" +# 49583 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined3_ in @@ -41204,15 +49587,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1046 "src/ocaml/preprocess/parser_raw.mly" +# 1083 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 41210 "src/ocaml/preprocess/parser_raw.ml" +# 49593 "src/ocaml/preprocess/parser_raw.ml" in -# 1558 "src/ocaml/preprocess/parser_raw.mly" +# 1619 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41216 "src/ocaml/preprocess/parser_raw.ml" +# 49599 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41291,9 +49674,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41297 "src/ocaml/preprocess/parser_raw.ml" +# 49680 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -41303,24 +49686,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 41309 "src/ocaml/preprocess/parser_raw.ml" +# 49692 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41317 "src/ocaml/preprocess/parser_raw.ml" +# 49700 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1603 "src/ocaml/preprocess/parser_raw.mly" +# 1668 "src/ocaml/preprocess/parser_raw.mly" ( let loc = make_loc _sloc in let attrs = attrs1 @ attrs2 in @@ -41328,25 +49711,25 @@ module Tables = struct ext, Mb.mk name body ~attrs ~loc ~docs ) -# 41332 "src/ocaml/preprocess/parser_raw.ml" +# 49715 "src/ocaml/preprocess/parser_raw.ml" in -# 1221 "src/ocaml/preprocess/parser_raw.mly" +# 1279 "src/ocaml/preprocess/parser_raw.mly" ( let (x, b) = a in x, b :: bs ) -# 41338 "src/ocaml/preprocess/parser_raw.ml" +# 49721 "src/ocaml/preprocess/parser_raw.ml" in -# 1591 "src/ocaml/preprocess/parser_raw.mly" +# 1656 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41344 "src/ocaml/preprocess/parser_raw.ml" +# 49727 "src/ocaml/preprocess/parser_raw.ml" in -# 1546 "src/ocaml/preprocess/parser_raw.mly" +# 1607 "src/ocaml/preprocess/parser_raw.mly" ( pstr_recmodule _1 ) -# 41350 "src/ocaml/preprocess/parser_raw.ml" +# 49733 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos_bs_ in @@ -41354,15 +49737,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1046 "src/ocaml/preprocess/parser_raw.mly" +# 1083 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 41360 "src/ocaml/preprocess/parser_raw.ml" +# 49743 "src/ocaml/preprocess/parser_raw.ml" in -# 1558 "src/ocaml/preprocess/parser_raw.mly" +# 1619 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41366 "src/ocaml/preprocess/parser_raw.ml" +# 49749 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41386,23 +49769,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.structure_item) = let _1 = let _1 = -# 1548 "src/ocaml/preprocess/parser_raw.mly" +# 1609 "src/ocaml/preprocess/parser_raw.mly" ( let (body, ext) = _1 in (Pstr_modtype body, ext) ) -# 41392 "src/ocaml/preprocess/parser_raw.ml" +# 49775 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1046 "src/ocaml/preprocess/parser_raw.mly" +# 1083 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 41400 "src/ocaml/preprocess/parser_raw.ml" +# 49783 "src/ocaml/preprocess/parser_raw.ml" in -# 1558 "src/ocaml/preprocess/parser_raw.mly" +# 1619 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41406 "src/ocaml/preprocess/parser_raw.ml" +# 49789 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41426,23 +49809,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.structure_item) = let _1 = let _1 = -# 1550 "src/ocaml/preprocess/parser_raw.mly" +# 1611 "src/ocaml/preprocess/parser_raw.mly" ( let (body, ext) = _1 in (Pstr_open body, ext) ) -# 41432 "src/ocaml/preprocess/parser_raw.ml" +# 49815 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1046 "src/ocaml/preprocess/parser_raw.mly" +# 1083 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 41440 "src/ocaml/preprocess/parser_raw.ml" +# 49823 "src/ocaml/preprocess/parser_raw.ml" in -# 1558 "src/ocaml/preprocess/parser_raw.mly" +# 1619 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41446 "src/ocaml/preprocess/parser_raw.ml" +# 49829 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41512,9 +49895,9 @@ module Tables = struct let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in let body : (Parsetree.class_expr) = Obj.magic body in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 41518 "src/ocaml/preprocess/parser_raw.ml" +# 49901 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in let virt : (Asttypes.virtual_flag) = Obj.magic virt in @@ -41532,9 +49915,9 @@ module Tables = struct let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41538 "src/ocaml/preprocess/parser_raw.ml" +# 49921 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -41544,24 +49927,24 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 41550 "src/ocaml/preprocess/parser_raw.ml" +# 49933 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41558 "src/ocaml/preprocess/parser_raw.ml" +# 49941 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1947 "src/ocaml/preprocess/parser_raw.mly" +# 2022 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in @@ -41569,25 +49952,25 @@ module Tables = struct ext, Ci.mk id body ~virt ~params ~attrs ~loc ~docs ) -# 41573 "src/ocaml/preprocess/parser_raw.ml" +# 49956 "src/ocaml/preprocess/parser_raw.ml" in -# 1221 "src/ocaml/preprocess/parser_raw.mly" +# 1279 "src/ocaml/preprocess/parser_raw.mly" ( let (x, b) = a in x, b :: bs ) -# 41579 "src/ocaml/preprocess/parser_raw.ml" +# 49962 "src/ocaml/preprocess/parser_raw.ml" in -# 1936 "src/ocaml/preprocess/parser_raw.mly" +# 2011 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41585 "src/ocaml/preprocess/parser_raw.ml" +# 49968 "src/ocaml/preprocess/parser_raw.ml" in -# 1552 "src/ocaml/preprocess/parser_raw.mly" +# 1613 "src/ocaml/preprocess/parser_raw.mly" ( let (ext, l) = _1 in (Pstr_class l, ext) ) -# 41591 "src/ocaml/preprocess/parser_raw.ml" +# 49974 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos_bs_ in @@ -41595,15 +49978,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1046 "src/ocaml/preprocess/parser_raw.mly" +# 1083 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 41601 "src/ocaml/preprocess/parser_raw.ml" +# 49984 "src/ocaml/preprocess/parser_raw.ml" in -# 1558 "src/ocaml/preprocess/parser_raw.mly" +# 1619 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41607 "src/ocaml/preprocess/parser_raw.ml" +# 49990 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41627,23 +50010,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.structure_item) = let _1 = let _1 = -# 1554 "src/ocaml/preprocess/parser_raw.mly" +# 1615 "src/ocaml/preprocess/parser_raw.mly" ( let (ext, l) = _1 in (Pstr_class_type l, ext) ) -# 41633 "src/ocaml/preprocess/parser_raw.ml" +# 50016 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1046 "src/ocaml/preprocess/parser_raw.mly" +# 1083 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 41641 "src/ocaml/preprocess/parser_raw.ml" +# 50024 "src/ocaml/preprocess/parser_raw.ml" in -# 1558 "src/ocaml/preprocess/parser_raw.mly" +# 1619 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41647 "src/ocaml/preprocess/parser_raw.ml" +# 50030 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41699,38 +50082,38 @@ module Tables = struct let attrs2 = let _1 = _1_inlined2 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41705 "src/ocaml/preprocess/parser_raw.ml" +# 50088 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined2_ in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41714 "src/ocaml/preprocess/parser_raw.ml" +# 50097 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1640 "src/ocaml/preprocess/parser_raw.mly" +# 1705 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in let docs = symbol_docs _sloc in Incl.mk thing ~attrs ~loc ~docs, ext ) -# 41728 "src/ocaml/preprocess/parser_raw.ml" +# 50111 "src/ocaml/preprocess/parser_raw.ml" in -# 1556 "src/ocaml/preprocess/parser_raw.mly" +# 1617 "src/ocaml/preprocess/parser_raw.mly" ( pstr_include _1 ) -# 41734 "src/ocaml/preprocess/parser_raw.ml" +# 50117 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos__1_inlined2_ in @@ -41738,15 +50121,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1046 "src/ocaml/preprocess/parser_raw.mly" +# 1083 "src/ocaml/preprocess/parser_raw.mly" ( wrap_mkstr_ext ~loc:_sloc _1 ) -# 41744 "src/ocaml/preprocess/parser_raw.ml" +# 50127 "src/ocaml/preprocess/parser_raw.ml" in -# 1558 "src/ocaml/preprocess/parser_raw.mly" +# 1619 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41750 "src/ocaml/preprocess/parser_raw.ml" +# 50133 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41769,9 +50152,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3937 "src/ocaml/preprocess/parser_raw.mly" +# 4133 "src/ocaml/preprocess/parser_raw.mly" ( "-" ) -# 41775 "src/ocaml/preprocess/parser_raw.ml" +# 50158 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41794,9 +50177,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3938 "src/ocaml/preprocess/parser_raw.mly" +# 4134 "src/ocaml/preprocess/parser_raw.mly" ( "-." ) -# 41800 "src/ocaml/preprocess/parser_raw.ml" +# 50183 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41849,9 +50232,9 @@ module Tables = struct let _v : (Parsetree.row_field) = let _5 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41855 "src/ocaml/preprocess/parser_raw.ml" +# 50238 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__5_ = _endpos__1_inlined1_ in @@ -41860,18 +50243,18 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 41864 "src/ocaml/preprocess/parser_raw.ml" +# 50247 "src/ocaml/preprocess/parser_raw.ml" in -# 1124 "src/ocaml/preprocess/parser_raw.mly" +# 1182 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 41869 "src/ocaml/preprocess/parser_raw.ml" +# 50252 "src/ocaml/preprocess/parser_raw.ml" in -# 3641 "src/ocaml/preprocess/parser_raw.mly" +# 3837 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41875 "src/ocaml/preprocess/parser_raw.ml" +# 50258 "src/ocaml/preprocess/parser_raw.ml" in let _1 = @@ -41879,20 +50262,20 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 41885 "src/ocaml/preprocess/parser_raw.ml" +# 50268 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3627 "src/ocaml/preprocess/parser_raw.mly" +# 3823 "src/ocaml/preprocess/parser_raw.mly" ( let info = symbol_info _endpos in let attrs = add_info_attrs info _5 in Rf.tag ~loc:(make_loc _sloc) ~attrs _1 _3 _4 ) -# 41896 "src/ocaml/preprocess/parser_raw.ml" +# 50279 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41924,9 +50307,9 @@ module Tables = struct let _v : (Parsetree.row_field) = let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 41930 "src/ocaml/preprocess/parser_raw.ml" +# 50313 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__2_ = _endpos__1_inlined1_ in @@ -41935,20 +50318,20 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 41941 "src/ocaml/preprocess/parser_raw.ml" +# 50324 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3631 "src/ocaml/preprocess/parser_raw.mly" +# 3827 "src/ocaml/preprocess/parser_raw.mly" ( let info = symbol_info _endpos in let attrs = add_info_attrs info _2 in Rf.tag ~loc:(make_loc _sloc) ~attrs _1 true [] ) -# 41952 "src/ocaml/preprocess/parser_raw.ml" +# 50335 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -41980,7 +50363,7 @@ module Tables = struct let _v : (Parsetree.toplevel_phrase) = let arg = # 124 "" ( None ) -# 41984 "src/ocaml/preprocess/parser_raw.ml" +# 50367 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_arg_ = _endpos__1_inlined1_ in let dir = @@ -41989,18 +50372,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 41995 "src/ocaml/preprocess/parser_raw.ml" +# 50378 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_arg_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3835 "src/ocaml/preprocess/parser_raw.mly" +# 4031 "src/ocaml/preprocess/parser_raw.mly" ( mk_directive ~loc:_sloc dir arg ) -# 42004 "src/ocaml/preprocess/parser_raw.ml" +# 50387 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42031,9 +50414,9 @@ module Tables = struct }; } = _menhir_stack in let _1_inlined2 : ( -# 831 "src/ocaml/preprocess/parser_raw.mly" +# 876 "src/ocaml/preprocess/parser_raw.mly" (string * Location.t * string option) -# 42037 "src/ocaml/preprocess/parser_raw.ml" +# 50420 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let _1_inlined1 : (string) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in @@ -42044,23 +50427,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let x = let _1 = -# 3839 "src/ocaml/preprocess/parser_raw.mly" +# 4035 "src/ocaml/preprocess/parser_raw.mly" ( let (s, _, _) = _1 in Pdir_string s ) -# 42050 "src/ocaml/preprocess/parser_raw.ml" +# 50433 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1051 "src/ocaml/preprocess/parser_raw.mly" +# 1088 "src/ocaml/preprocess/parser_raw.mly" ( mk_directive_arg ~loc:_sloc _1 ) -# 42058 "src/ocaml/preprocess/parser_raw.ml" +# 50441 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 42064 "src/ocaml/preprocess/parser_raw.ml" +# 50447 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_arg_ = _endpos__1_inlined2_ in @@ -42070,18 +50453,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 42076 "src/ocaml/preprocess/parser_raw.ml" +# 50459 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_arg_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3835 "src/ocaml/preprocess/parser_raw.mly" +# 4031 "src/ocaml/preprocess/parser_raw.mly" ( mk_directive ~loc:_sloc dir arg ) -# 42085 "src/ocaml/preprocess/parser_raw.ml" +# 50468 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42112,9 +50495,9 @@ module Tables = struct }; } = _menhir_stack in let _1_inlined2 : ( -# 779 "src/ocaml/preprocess/parser_raw.mly" +# 824 "src/ocaml/preprocess/parser_raw.mly" (string * char option) -# 42118 "src/ocaml/preprocess/parser_raw.ml" +# 50501 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let _1_inlined1 : (string) = Obj.magic _1_inlined1 in let _1 : unit = Obj.magic _1 in @@ -42125,23 +50508,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let x = let _1 = -# 3840 "src/ocaml/preprocess/parser_raw.mly" +# 4036 "src/ocaml/preprocess/parser_raw.mly" ( let (n, m) = _1 in Pdir_int (n ,m) ) -# 42131 "src/ocaml/preprocess/parser_raw.ml" +# 50514 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1051 "src/ocaml/preprocess/parser_raw.mly" +# 1088 "src/ocaml/preprocess/parser_raw.mly" ( mk_directive_arg ~loc:_sloc _1 ) -# 42139 "src/ocaml/preprocess/parser_raw.ml" +# 50522 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 42145 "src/ocaml/preprocess/parser_raw.ml" +# 50528 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_arg_ = _endpos__1_inlined2_ in @@ -42151,18 +50534,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 42157 "src/ocaml/preprocess/parser_raw.ml" +# 50540 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_arg_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3835 "src/ocaml/preprocess/parser_raw.mly" +# 4031 "src/ocaml/preprocess/parser_raw.mly" ( mk_directive ~loc:_sloc dir arg ) -# 42166 "src/ocaml/preprocess/parser_raw.ml" +# 50549 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42202,23 +50585,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let x = let _1 = -# 3841 "src/ocaml/preprocess/parser_raw.mly" +# 4037 "src/ocaml/preprocess/parser_raw.mly" ( Pdir_ident _1 ) -# 42208 "src/ocaml/preprocess/parser_raw.ml" +# 50591 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1051 "src/ocaml/preprocess/parser_raw.mly" +# 1088 "src/ocaml/preprocess/parser_raw.mly" ( mk_directive_arg ~loc:_sloc _1 ) -# 42216 "src/ocaml/preprocess/parser_raw.ml" +# 50599 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 42222 "src/ocaml/preprocess/parser_raw.ml" +# 50605 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_arg_ = _endpos__1_inlined2_ in @@ -42228,18 +50611,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 42234 "src/ocaml/preprocess/parser_raw.ml" +# 50617 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_arg_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3835 "src/ocaml/preprocess/parser_raw.mly" +# 4031 "src/ocaml/preprocess/parser_raw.mly" ( mk_directive ~loc:_sloc dir arg ) -# 42243 "src/ocaml/preprocess/parser_raw.ml" +# 50626 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42279,23 +50662,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let x = let _1 = -# 3842 "src/ocaml/preprocess/parser_raw.mly" +# 4038 "src/ocaml/preprocess/parser_raw.mly" ( Pdir_ident _1 ) -# 42285 "src/ocaml/preprocess/parser_raw.ml" +# 50668 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1051 "src/ocaml/preprocess/parser_raw.mly" +# 1088 "src/ocaml/preprocess/parser_raw.mly" ( mk_directive_arg ~loc:_sloc _1 ) -# 42293 "src/ocaml/preprocess/parser_raw.ml" +# 50676 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 42299 "src/ocaml/preprocess/parser_raw.ml" +# 50682 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_arg_ = _endpos__1_inlined2_ in @@ -42305,18 +50688,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 42311 "src/ocaml/preprocess/parser_raw.ml" +# 50694 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_arg_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3835 "src/ocaml/preprocess/parser_raw.mly" +# 4031 "src/ocaml/preprocess/parser_raw.mly" ( mk_directive ~loc:_sloc dir arg ) -# 42320 "src/ocaml/preprocess/parser_raw.ml" +# 50703 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42356,23 +50739,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let x = let _1 = -# 3843 "src/ocaml/preprocess/parser_raw.mly" +# 4039 "src/ocaml/preprocess/parser_raw.mly" ( Pdir_bool false ) -# 42362 "src/ocaml/preprocess/parser_raw.ml" +# 50745 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1051 "src/ocaml/preprocess/parser_raw.mly" +# 1088 "src/ocaml/preprocess/parser_raw.mly" ( mk_directive_arg ~loc:_sloc _1 ) -# 42370 "src/ocaml/preprocess/parser_raw.ml" +# 50753 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 42376 "src/ocaml/preprocess/parser_raw.ml" +# 50759 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_arg_ = _endpos__1_inlined2_ in @@ -42382,18 +50765,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 42388 "src/ocaml/preprocess/parser_raw.ml" +# 50771 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_arg_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3835 "src/ocaml/preprocess/parser_raw.mly" +# 4031 "src/ocaml/preprocess/parser_raw.mly" ( mk_directive ~loc:_sloc dir arg ) -# 42397 "src/ocaml/preprocess/parser_raw.ml" +# 50780 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42433,23 +50816,23 @@ module Tables = struct let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let x = let _1 = -# 3844 "src/ocaml/preprocess/parser_raw.mly" +# 4040 "src/ocaml/preprocess/parser_raw.mly" ( Pdir_bool true ) -# 42439 "src/ocaml/preprocess/parser_raw.ml" +# 50822 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1051 "src/ocaml/preprocess/parser_raw.mly" +# 1088 "src/ocaml/preprocess/parser_raw.mly" ( mk_directive_arg ~loc:_sloc _1 ) -# 42447 "src/ocaml/preprocess/parser_raw.ml" +# 50830 "src/ocaml/preprocess/parser_raw.ml" in # 126 "" ( Some x ) -# 42453 "src/ocaml/preprocess/parser_raw.ml" +# 50836 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_arg_ = _endpos__1_inlined2_ in @@ -42459,18 +50842,18 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 42465 "src/ocaml/preprocess/parser_raw.ml" +# 50848 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_arg_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3835 "src/ocaml/preprocess/parser_raw.mly" +# 4031 "src/ocaml/preprocess/parser_raw.mly" ( mk_directive ~loc:_sloc dir arg ) -# 42474 "src/ocaml/preprocess/parser_raw.ml" +# 50857 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42510,37 +50893,37 @@ module Tables = struct let _1 = let _1 = let attrs = -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 42516 "src/ocaml/preprocess/parser_raw.ml" +# 50899 "src/ocaml/preprocess/parser_raw.ml" in -# 1509 "src/ocaml/preprocess/parser_raw.mly" +# 1570 "src/ocaml/preprocess/parser_raw.mly" ( mkstrexp e attrs ) -# 42521 "src/ocaml/preprocess/parser_raw.ml" +# 50904 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__1_ = _startpos_e_ in let _startpos = _startpos__1_ in -# 994 "src/ocaml/preprocess/parser_raw.mly" +# 1031 "src/ocaml/preprocess/parser_raw.mly" ( text_str _startpos @ [_1] ) -# 42529 "src/ocaml/preprocess/parser_raw.ml" +# 50912 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__1_ = _startpos_e_ in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 982 "src/ocaml/preprocess/parser_raw.mly" +# 1019 "src/ocaml/preprocess/parser_raw.mly" ( extra_str _startpos _endpos _1 ) -# 42538 "src/ocaml/preprocess/parser_raw.ml" +# 50921 "src/ocaml/preprocess/parser_raw.ml" in -# 1261 "src/ocaml/preprocess/parser_raw.mly" +# 1319 "src/ocaml/preprocess/parser_raw.mly" ( Ptop_def _1 ) -# 42544 "src/ocaml/preprocess/parser_raw.ml" +# 50927 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42573,21 +50956,21 @@ module Tables = struct let _1 = # 260 "" ( List.flatten xss ) -# 42577 "src/ocaml/preprocess/parser_raw.ml" +# 50960 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 982 "src/ocaml/preprocess/parser_raw.mly" +# 1019 "src/ocaml/preprocess/parser_raw.mly" ( extra_str _startpos _endpos _1 ) -# 42585 "src/ocaml/preprocess/parser_raw.ml" +# 50968 "src/ocaml/preprocess/parser_raw.ml" in -# 1265 "src/ocaml/preprocess/parser_raw.mly" +# 1323 "src/ocaml/preprocess/parser_raw.mly" ( Ptop_def _1 ) -# 42591 "src/ocaml/preprocess/parser_raw.ml" +# 50974 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42617,9 +51000,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.toplevel_phrase) = -# 1269 "src/ocaml/preprocess/parser_raw.mly" +# 1327 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 42623 "src/ocaml/preprocess/parser_raw.ml" +# 51006 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42642,9 +51025,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Parsetree.toplevel_phrase) = -# 1272 "src/ocaml/preprocess/parser_raw.mly" +# 1330 "src/ocaml/preprocess/parser_raw.mly" ( raise End_of_file ) -# 42648 "src/ocaml/preprocess/parser_raw.ml" +# 51031 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42667,9 +51050,9 @@ module Tables = struct let _startpos = _startpos_ty_ in let _endpos = _endpos_ty_ in let _v : (Parsetree.core_type) = -# 3533 "src/ocaml/preprocess/parser_raw.mly" +# 3673 "src/ocaml/preprocess/parser_raw.mly" ( ty ) -# 42673 "src/ocaml/preprocess/parser_raw.ml" +# 51056 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42697,18 +51080,18 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 42701 "src/ocaml/preprocess/parser_raw.ml" +# 51084 "src/ocaml/preprocess/parser_raw.ml" in -# 1152 "src/ocaml/preprocess/parser_raw.mly" +# 1210 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 42706 "src/ocaml/preprocess/parser_raw.ml" +# 51089 "src/ocaml/preprocess/parser_raw.ml" in -# 3536 "src/ocaml/preprocess/parser_raw.mly" +# 3676 "src/ocaml/preprocess/parser_raw.mly" ( Ptyp_tuple tys ) -# 42712 "src/ocaml/preprocess/parser_raw.ml" +# 51095 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_xs_) in @@ -42716,15 +51099,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 42722 "src/ocaml/preprocess/parser_raw.ml" +# 51105 "src/ocaml/preprocess/parser_raw.ml" in -# 3538 "src/ocaml/preprocess/parser_raw.mly" +# 3678 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 42728 "src/ocaml/preprocess/parser_raw.ml" +# 51111 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42753,10 +51136,10 @@ module Tables = struct let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in - let _v : (Parsetree.core_type option * Parsetree.core_type option) = -# 2849 "src/ocaml/preprocess/parser_raw.mly" - ( (Some _2, None) ) -# 42760 "src/ocaml/preprocess/parser_raw.ml" + let _v : (Parsetree.type_constraint) = +# 2989 "src/ocaml/preprocess/parser_raw.mly" + ( Pconstraint _2 ) +# 51143 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42799,10 +51182,10 @@ module Tables = struct let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in - let _v : (Parsetree.core_type option * Parsetree.core_type option) = -# 2850 "src/ocaml/preprocess/parser_raw.mly" - ( (Some _2, Some _4) ) -# 42806 "src/ocaml/preprocess/parser_raw.ml" + let _v : (Parsetree.type_constraint) = +# 2990 "src/ocaml/preprocess/parser_raw.mly" + ( Pcoerce (Some _2, _4) ) +# 51189 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42831,10 +51214,10 @@ module Tables = struct let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in - let _v : (Parsetree.core_type option * Parsetree.core_type option) = -# 2851 "src/ocaml/preprocess/parser_raw.mly" - ( (None, Some _2) ) -# 42838 "src/ocaml/preprocess/parser_raw.ml" + let _v : (Parsetree.type_constraint) = +# 2991 "src/ocaml/preprocess/parser_raw.mly" + ( Pcoerce (None, _2) ) +# 51221 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42850,9 +51233,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = -# 3186 "src/ocaml/preprocess/parser_raw.mly" +# 3326 "src/ocaml/preprocess/parser_raw.mly" ( (Ptype_abstract, Public, None) ) -# 42856 "src/ocaml/preprocess/parser_raw.ml" +# 51239 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42882,9 +51265,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = -# 3188 "src/ocaml/preprocess/parser_raw.mly" +# 3328 "src/ocaml/preprocess/parser_raw.mly" ( _2 ) -# 42888 "src/ocaml/preprocess/parser_raw.ml" +# 51271 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42907,9 +51290,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3794 "src/ocaml/preprocess/parser_raw.mly" +# 3990 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 42913 "src/ocaml/preprocess/parser_raw.ml" +# 51296 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42939,9 +51322,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) = -# 3203 "src/ocaml/preprocess/parser_raw.mly" +# 3343 "src/ocaml/preprocess/parser_raw.mly" ( _2, _1 ) -# 42945 "src/ocaml/preprocess/parser_raw.ml" +# 51328 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42957,9 +51340,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = -# 3196 "src/ocaml/preprocess/parser_raw.mly" +# 3336 "src/ocaml/preprocess/parser_raw.mly" ( [] ) -# 42963 "src/ocaml/preprocess/parser_raw.ml" +# 51346 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -42982,9 +51365,9 @@ module Tables = struct let _startpos = _startpos_p_ in let _endpos = _endpos_p_ in let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = -# 3198 "src/ocaml/preprocess/parser_raw.mly" +# 3338 "src/ocaml/preprocess/parser_raw.mly" ( [p] ) -# 42988 "src/ocaml/preprocess/parser_raw.ml" +# 51371 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43024,18 +51407,18 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 43028 "src/ocaml/preprocess/parser_raw.ml" +# 51411 "src/ocaml/preprocess/parser_raw.ml" in -# 1124 "src/ocaml/preprocess/parser_raw.mly" +# 1182 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 43033 "src/ocaml/preprocess/parser_raw.ml" +# 51416 "src/ocaml/preprocess/parser_raw.ml" in -# 3200 "src/ocaml/preprocess/parser_raw.mly" +# 3340 "src/ocaml/preprocess/parser_raw.mly" ( ps ) -# 43039 "src/ocaml/preprocess/parser_raw.ml" +# 51422 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43066,24 +51449,24 @@ module Tables = struct let _endpos = _endpos_tyvar_ in let _v : (Parsetree.core_type) = let _1 = let _1 = -# 3208 "src/ocaml/preprocess/parser_raw.mly" +# 3348 "src/ocaml/preprocess/parser_raw.mly" ( Ptyp_var tyvar ) -# 43072 "src/ocaml/preprocess/parser_raw.ml" +# 51455 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__1_ = _endpos_tyvar_ in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 43081 "src/ocaml/preprocess/parser_raw.ml" +# 51464 "src/ocaml/preprocess/parser_raw.ml" in -# 3211 "src/ocaml/preprocess/parser_raw.mly" +# 3351 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 43087 "src/ocaml/preprocess/parser_raw.ml" +# 51470 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43107,23 +51490,23 @@ module Tables = struct let _endpos = _endpos__1_ in let _v : (Parsetree.core_type) = let _1 = let _1 = -# 3210 "src/ocaml/preprocess/parser_raw.mly" +# 3350 "src/ocaml/preprocess/parser_raw.mly" ( Ptyp_any ) -# 43113 "src/ocaml/preprocess/parser_raw.ml" +# 51496 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 1027 "src/ocaml/preprocess/parser_raw.mly" +# 1064 "src/ocaml/preprocess/parser_raw.mly" ( mktyp ~loc:_sloc _1 ) -# 43121 "src/ocaml/preprocess/parser_raw.ml" +# 51504 "src/ocaml/preprocess/parser_raw.ml" in -# 3211 "src/ocaml/preprocess/parser_raw.mly" +# 3351 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 43127 "src/ocaml/preprocess/parser_raw.ml" +# 51510 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43139,9 +51522,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Asttypes.variance * Asttypes.injectivity) = -# 3215 "src/ocaml/preprocess/parser_raw.mly" +# 3355 "src/ocaml/preprocess/parser_raw.mly" ( NoVariance, NoInjectivity ) -# 43145 "src/ocaml/preprocess/parser_raw.ml" +# 51528 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43164,9 +51547,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.variance * Asttypes.injectivity) = -# 3216 "src/ocaml/preprocess/parser_raw.mly" +# 3356 "src/ocaml/preprocess/parser_raw.mly" ( Covariant, NoInjectivity ) -# 43170 "src/ocaml/preprocess/parser_raw.ml" +# 51553 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43189,9 +51572,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.variance * Asttypes.injectivity) = -# 3217 "src/ocaml/preprocess/parser_raw.mly" +# 3357 "src/ocaml/preprocess/parser_raw.mly" ( Contravariant, NoInjectivity ) -# 43195 "src/ocaml/preprocess/parser_raw.ml" +# 51578 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43214,9 +51597,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.variance * Asttypes.injectivity) = -# 3218 "src/ocaml/preprocess/parser_raw.mly" +# 3358 "src/ocaml/preprocess/parser_raw.mly" ( NoVariance, Injective ) -# 43220 "src/ocaml/preprocess/parser_raw.ml" +# 51603 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43246,9 +51629,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.variance * Asttypes.injectivity) = -# 3219 "src/ocaml/preprocess/parser_raw.mly" +# 3359 "src/ocaml/preprocess/parser_raw.mly" ( Covariant, Injective ) -# 43252 "src/ocaml/preprocess/parser_raw.ml" +# 51635 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43278,9 +51661,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.variance * Asttypes.injectivity) = -# 3219 "src/ocaml/preprocess/parser_raw.mly" +# 3359 "src/ocaml/preprocess/parser_raw.mly" ( Covariant, Injective ) -# 43284 "src/ocaml/preprocess/parser_raw.ml" +# 51667 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43310,9 +51693,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.variance * Asttypes.injectivity) = -# 3220 "src/ocaml/preprocess/parser_raw.mly" +# 3360 "src/ocaml/preprocess/parser_raw.mly" ( Contravariant, Injective ) -# 43316 "src/ocaml/preprocess/parser_raw.ml" +# 51699 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43342,9 +51725,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.variance * Asttypes.injectivity) = -# 3220 "src/ocaml/preprocess/parser_raw.mly" +# 3360 "src/ocaml/preprocess/parser_raw.mly" ( Contravariant, Injective ) -# 43348 "src/ocaml/preprocess/parser_raw.ml" +# 51731 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43363,21 +51746,21 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 771 "src/ocaml/preprocess/parser_raw.mly" +# 816 "src/ocaml/preprocess/parser_raw.mly" (string) -# 43369 "src/ocaml/preprocess/parser_raw.ml" +# 51752 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.variance * Asttypes.injectivity) = let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 3222 "src/ocaml/preprocess/parser_raw.mly" +# 3362 "src/ocaml/preprocess/parser_raw.mly" ( if _1 = "+!" then Covariant, Injective else if _1 = "-!" then Contravariant, Injective else (expecting _loc__1_ "type_variance"; NoVariance, NoInjectivity) ) -# 43381 "src/ocaml/preprocess/parser_raw.ml" +# 51764 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43396,21 +51779,21 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 817 "src/ocaml/preprocess/parser_raw.mly" +# 862 "src/ocaml/preprocess/parser_raw.mly" (string) -# 43402 "src/ocaml/preprocess/parser_raw.ml" +# 51785 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.variance * Asttypes.injectivity) = let _loc__1_ = (_startpos__1_, _endpos__1_) in -# 3227 "src/ocaml/preprocess/parser_raw.mly" +# 3367 "src/ocaml/preprocess/parser_raw.mly" ( if _1 = "!+" then Covariant, Injective else if _1 = "!-" then Contravariant, Injective else (expecting _loc__1_ "type_variance"; NoVariance, NoInjectivity) ) -# 43414 "src/ocaml/preprocess/parser_raw.ml" +# 51797 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43444,39 +51827,39 @@ module Tables = struct let ys = # 260 "" ( List.flatten xss ) -# 43448 "src/ocaml/preprocess/parser_raw.ml" +# 51831 "src/ocaml/preprocess/parser_raw.ml" in let xs = let _1 = -# 1060 "src/ocaml/preprocess/parser_raw.mly" +# 1097 "src/ocaml/preprocess/parser_raw.mly" ( [] ) -# 43454 "src/ocaml/preprocess/parser_raw.ml" +# 51837 "src/ocaml/preprocess/parser_raw.ml" in -# 1292 "src/ocaml/preprocess/parser_raw.mly" +# 1350 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 43459 "src/ocaml/preprocess/parser_raw.ml" +# 51842 "src/ocaml/preprocess/parser_raw.ml" in # 267 "" ( xs @ ys ) -# 43465 "src/ocaml/preprocess/parser_raw.ml" +# 51848 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 986 "src/ocaml/preprocess/parser_raw.mly" +# 1023 "src/ocaml/preprocess/parser_raw.mly" ( extra_def _startpos _endpos _1 ) -# 43474 "src/ocaml/preprocess/parser_raw.ml" +# 51857 "src/ocaml/preprocess/parser_raw.ml" in -# 1285 "src/ocaml/preprocess/parser_raw.mly" +# 1343 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 43480 "src/ocaml/preprocess/parser_raw.ml" +# 51863 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43524,7 +51907,7 @@ module Tables = struct let ys = # 260 "" ( List.flatten xss ) -# 43528 "src/ocaml/preprocess/parser_raw.ml" +# 51911 "src/ocaml/preprocess/parser_raw.ml" in let xs = let _1 = @@ -43532,61 +51915,61 @@ module Tables = struct let _1 = let _1 = let attrs = -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 43538 "src/ocaml/preprocess/parser_raw.ml" +# 51921 "src/ocaml/preprocess/parser_raw.ml" in -# 1509 "src/ocaml/preprocess/parser_raw.mly" +# 1570 "src/ocaml/preprocess/parser_raw.mly" ( mkstrexp e attrs ) -# 43543 "src/ocaml/preprocess/parser_raw.ml" +# 51926 "src/ocaml/preprocess/parser_raw.ml" in -# 1004 "src/ocaml/preprocess/parser_raw.mly" +# 1041 "src/ocaml/preprocess/parser_raw.mly" ( Ptop_def [_1] ) -# 43549 "src/ocaml/preprocess/parser_raw.ml" +# 51932 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__1_ = _startpos_e_ in let _startpos = _startpos__1_ in -# 1002 "src/ocaml/preprocess/parser_raw.mly" +# 1039 "src/ocaml/preprocess/parser_raw.mly" ( text_def _startpos @ [_1] ) -# 43557 "src/ocaml/preprocess/parser_raw.ml" +# 51940 "src/ocaml/preprocess/parser_raw.ml" in -# 1062 "src/ocaml/preprocess/parser_raw.mly" +# 1099 "src/ocaml/preprocess/parser_raw.mly" ( x ) -# 43563 "src/ocaml/preprocess/parser_raw.ml" +# 51946 "src/ocaml/preprocess/parser_raw.ml" in -# 1292 "src/ocaml/preprocess/parser_raw.mly" +# 1350 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 43569 "src/ocaml/preprocess/parser_raw.ml" +# 51952 "src/ocaml/preprocess/parser_raw.ml" in # 267 "" ( xs @ ys ) -# 43575 "src/ocaml/preprocess/parser_raw.ml" +# 51958 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_e_) in let _endpos = _endpos__1_ in let _startpos = _startpos__1_ in -# 986 "src/ocaml/preprocess/parser_raw.mly" +# 1023 "src/ocaml/preprocess/parser_raw.mly" ( extra_def _startpos _endpos _1 ) -# 43584 "src/ocaml/preprocess/parser_raw.ml" +# 51967 "src/ocaml/preprocess/parser_raw.ml" in -# 1285 "src/ocaml/preprocess/parser_raw.mly" +# 1343 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 43590 "src/ocaml/preprocess/parser_raw.ml" +# 51973 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43623,9 +52006,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : (string) = -# 3711 "src/ocaml/preprocess/parser_raw.mly" +# 3907 "src/ocaml/preprocess/parser_raw.mly" ( _2 ) -# 43629 "src/ocaml/preprocess/parser_raw.ml" +# 52012 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43644,17 +52027,17 @@ module Tables = struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 43650 "src/ocaml/preprocess/parser_raw.ml" +# 52033 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1 in let _endpos__0_ = _menhir_stack.MenhirLib.EngineTypes.endp in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3719 "src/ocaml/preprocess/parser_raw.mly" +# 3915 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 43658 "src/ocaml/preprocess/parser_raw.ml" +# 52041 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43677,9 +52060,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (string) = -# 3720 "src/ocaml/preprocess/parser_raw.mly" +# 3916 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 43683 "src/ocaml/preprocess/parser_raw.ml" +# 52066 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43702,9 +52085,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Longident.t) = -# 3788 "src/ocaml/preprocess/parser_raw.mly" +# 3984 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 43708 "src/ocaml/preprocess/parser_raw.ml" +# 52091 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43749,9 +52132,9 @@ module Tables = struct let ty : (Parsetree.core_type) = Obj.magic ty in let _5 : unit = Obj.magic _5 in let _1_inlined1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 43755 "src/ocaml/preprocess/parser_raw.ml" +# 52138 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined1 in let mutable_ : (Asttypes.mutable_flag) = Obj.magic mutable_ in let _1 : (Parsetree.attributes) = Obj.magic _1 in @@ -43762,33 +52145,33 @@ module Tables = struct Parsetree.attributes) = let label = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 43768 "src/ocaml/preprocess/parser_raw.ml" +# 52151 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 43776 "src/ocaml/preprocess/parser_raw.ml" +# 52159 "src/ocaml/preprocess/parser_raw.ml" in let attrs = -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 43782 "src/ocaml/preprocess/parser_raw.ml" +# 52165 "src/ocaml/preprocess/parser_raw.ml" in let _1 = -# 3930 "src/ocaml/preprocess/parser_raw.mly" +# 4126 "src/ocaml/preprocess/parser_raw.mly" ( Fresh ) -# 43787 "src/ocaml/preprocess/parser_raw.ml" +# 52170 "src/ocaml/preprocess/parser_raw.ml" in -# 2093 "src/ocaml/preprocess/parser_raw.mly" +# 2168 "src/ocaml/preprocess/parser_raw.mly" ( (label, mutable_, Cfk_virtual ty), attrs ) -# 43792 "src/ocaml/preprocess/parser_raw.ml" +# 52175 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43833,9 +52216,9 @@ module Tables = struct let _6 : (Parsetree.expression) = Obj.magic _6 in let _5 : unit = Obj.magic _5 in let _1_inlined1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 43839 "src/ocaml/preprocess/parser_raw.ml" +# 52222 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined1 in let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in let _1 : (Parsetree.attributes) = Obj.magic _1 in @@ -43846,33 +52229,33 @@ module Tables = struct Parsetree.attributes) = let _4 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 43852 "src/ocaml/preprocess/parser_raw.ml" +# 52235 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 43860 "src/ocaml/preprocess/parser_raw.ml" +# 52243 "src/ocaml/preprocess/parser_raw.ml" in let _2 = -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 43866 "src/ocaml/preprocess/parser_raw.ml" +# 52249 "src/ocaml/preprocess/parser_raw.ml" in let _1 = -# 3933 "src/ocaml/preprocess/parser_raw.mly" +# 4129 "src/ocaml/preprocess/parser_raw.mly" ( Fresh ) -# 43871 "src/ocaml/preprocess/parser_raw.ml" +# 52254 "src/ocaml/preprocess/parser_raw.ml" in -# 2095 "src/ocaml/preprocess/parser_raw.mly" +# 2170 "src/ocaml/preprocess/parser_raw.mly" ( (_4, _3, Cfk_concrete (_1, _6)), _2 ) -# 43876 "src/ocaml/preprocess/parser_raw.ml" +# 52259 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -43923,9 +52306,9 @@ module Tables = struct let _6 : (Parsetree.expression) = Obj.magic _6 in let _5 : unit = Obj.magic _5 in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 43929 "src/ocaml/preprocess/parser_raw.ml" +# 52312 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in @@ -43937,36 +52320,36 @@ module Tables = struct Parsetree.attributes) = let _4 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 43943 "src/ocaml/preprocess/parser_raw.ml" +# 52326 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 43951 "src/ocaml/preprocess/parser_raw.ml" +# 52334 "src/ocaml/preprocess/parser_raw.ml" in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 43959 "src/ocaml/preprocess/parser_raw.ml" +# 52342 "src/ocaml/preprocess/parser_raw.ml" in let _1 = -# 3934 "src/ocaml/preprocess/parser_raw.mly" +# 4130 "src/ocaml/preprocess/parser_raw.mly" ( Override ) -# 43965 "src/ocaml/preprocess/parser_raw.ml" +# 52348 "src/ocaml/preprocess/parser_raw.ml" in -# 2095 "src/ocaml/preprocess/parser_raw.mly" +# 2170 "src/ocaml/preprocess/parser_raw.mly" ( (_4, _3, Cfk_concrete (_1, _6)), _2 ) -# 43970 "src/ocaml/preprocess/parser_raw.ml" +# 52353 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44016,11 +52399,11 @@ module Tables = struct } = _menhir_stack in let _7 : (Parsetree.expression) = Obj.magic _7 in let _6 : unit = Obj.magic _6 in - let _5 : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic _5 in + let _5 : (Parsetree.type_constraint) = Obj.magic _5 in let _1_inlined1 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 44024 "src/ocaml/preprocess/parser_raw.ml" +# 52407 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined1 in let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in let _1 : (Parsetree.attributes) = Obj.magic _1 in @@ -44031,30 +52414,30 @@ module Tables = struct Parsetree.attributes) = let _4 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 44037 "src/ocaml/preprocess/parser_raw.ml" +# 52420 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 44045 "src/ocaml/preprocess/parser_raw.ml" +# 52428 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__4_ = _startpos__1_inlined1_ in let _2 = -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 44052 "src/ocaml/preprocess/parser_raw.ml" +# 52435 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__2_, _startpos__2_) = (_endpos__1_, _startpos__1_) in let _1 = -# 3933 "src/ocaml/preprocess/parser_raw.mly" +# 4129 "src/ocaml/preprocess/parser_raw.mly" ( Fresh ) -# 44058 "src/ocaml/preprocess/parser_raw.ml" +# 52441 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__1_, _startpos__1_) = (_endpos__0_, _endpos__0_) in let _endpos = _endpos__7_ in @@ -44070,11 +52453,11 @@ module Tables = struct _startpos__4_ in let _sloc = (_symbolstartpos, _endpos) in -# 2098 "src/ocaml/preprocess/parser_raw.mly" +# 2173 "src/ocaml/preprocess/parser_raw.mly" ( let e = mkexp_constraint ~loc:_sloc _7 _5 in (_4, _3, Cfk_concrete (_1, e)), _2 ) -# 44078 "src/ocaml/preprocess/parser_raw.ml" +# 52461 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44130,11 +52513,11 @@ module Tables = struct } = _menhir_stack in let _7 : (Parsetree.expression) = Obj.magic _7 in let _6 : unit = Obj.magic _6 in - let _5 : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic _5 in + let _5 : (Parsetree.type_constraint) = Obj.magic _5 in let _1_inlined2 : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 44138 "src/ocaml/preprocess/parser_raw.ml" +# 52521 "src/ocaml/preprocess/parser_raw.ml" ) = Obj.magic _1_inlined2 in let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in @@ -44146,33 +52529,33 @@ module Tables = struct Parsetree.attributes) = let _4 = let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in let _1 = -# 3685 "src/ocaml/preprocess/parser_raw.mly" +# 3881 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 44152 "src/ocaml/preprocess/parser_raw.ml" +# 52535 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__1_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 44160 "src/ocaml/preprocess/parser_raw.ml" +# 52543 "src/ocaml/preprocess/parser_raw.ml" in let _startpos__4_ = _startpos__1_inlined2_ in let _2 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 44169 "src/ocaml/preprocess/parser_raw.ml" +# 52552 "src/ocaml/preprocess/parser_raw.ml" in let (_endpos__2_, _startpos__2_) = (_endpos__1_inlined1_, _startpos__1_inlined1_) in let _1 = -# 3934 "src/ocaml/preprocess/parser_raw.mly" +# 4130 "src/ocaml/preprocess/parser_raw.mly" ( Override ) -# 44176 "src/ocaml/preprocess/parser_raw.ml" +# 52559 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__7_ in let _symbolstartpos = if _startpos__1_ != _endpos__1_ then @@ -44187,11 +52570,11 @@ module Tables = struct _startpos__4_ in let _sloc = (_symbolstartpos, _endpos) in -# 2098 "src/ocaml/preprocess/parser_raw.mly" +# 2173 "src/ocaml/preprocess/parser_raw.mly" ( let e = mkexp_constraint ~loc:_sloc _7 _5 in (_4, _3, Cfk_concrete (_1, e)), _2 ) -# 44195 "src/ocaml/preprocess/parser_raw.ml" +# 52578 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44258,9 +52641,9 @@ module Tables = struct let _v : (Parsetree.value_description * string Location.loc option) = let attrs2 = let _1 = _1_inlined3 in -# 4027 "src/ocaml/preprocess/parser_raw.mly" +# 4223 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 44264 "src/ocaml/preprocess/parser_raw.ml" +# 52647 "src/ocaml/preprocess/parser_raw.ml" in let _endpos_attrs2_ = _endpos__1_inlined3_ in @@ -44270,30 +52653,30 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 44276 "src/ocaml/preprocess/parser_raw.ml" +# 52659 "src/ocaml/preprocess/parser_raw.ml" in let attrs1 = let _1 = _1_inlined1 in -# 4031 "src/ocaml/preprocess/parser_raw.mly" +# 4227 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 44284 "src/ocaml/preprocess/parser_raw.ml" +# 52667 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos_attrs2_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3057 "src/ocaml/preprocess/parser_raw.mly" +# 3197 "src/ocaml/preprocess/parser_raw.mly" ( let attrs = attrs1 @ attrs2 in let loc = make_loc _sloc in let docs = symbol_docs _sloc in Val.mk id ty ~attrs ~loc ~docs, ext ) -# 44297 "src/ocaml/preprocess/parser_raw.ml" +# 52680 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44309,9 +52692,9 @@ module Tables = struct let _startpos = _menhir_stack.MenhirLib.EngineTypes.endp in let _endpos = _startpos in let _v : (Asttypes.virtual_flag) = -# 3894 "src/ocaml/preprocess/parser_raw.mly" +# 4090 "src/ocaml/preprocess/parser_raw.mly" ( Concrete ) -# 44315 "src/ocaml/preprocess/parser_raw.ml" +# 52698 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44334,9 +52717,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.virtual_flag) = -# 3895 "src/ocaml/preprocess/parser_raw.mly" +# 4091 "src/ocaml/preprocess/parser_raw.mly" ( Virtual ) -# 44340 "src/ocaml/preprocess/parser_raw.ml" +# 52723 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44359,9 +52742,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.mutable_flag) = -# 3918 "src/ocaml/preprocess/parser_raw.mly" +# 4114 "src/ocaml/preprocess/parser_raw.mly" ( Immutable ) -# 44365 "src/ocaml/preprocess/parser_raw.ml" +# 52748 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44391,9 +52774,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.mutable_flag) = -# 3919 "src/ocaml/preprocess/parser_raw.mly" +# 4115 "src/ocaml/preprocess/parser_raw.mly" ( Mutable ) -# 44397 "src/ocaml/preprocess/parser_raw.ml" +# 52780 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44423,9 +52806,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.mutable_flag) = -# 3920 "src/ocaml/preprocess/parser_raw.mly" +# 4116 "src/ocaml/preprocess/parser_raw.mly" ( Mutable ) -# 44429 "src/ocaml/preprocess/parser_raw.ml" +# 52812 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44448,9 +52831,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.private_flag) = -# 3925 "src/ocaml/preprocess/parser_raw.mly" +# 4121 "src/ocaml/preprocess/parser_raw.mly" ( Public ) -# 44454 "src/ocaml/preprocess/parser_raw.ml" +# 52837 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44480,9 +52863,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.private_flag) = -# 3926 "src/ocaml/preprocess/parser_raw.mly" +# 4122 "src/ocaml/preprocess/parser_raw.mly" ( Private ) -# 44486 "src/ocaml/preprocess/parser_raw.ml" +# 52869 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44512,9 +52895,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.private_flag) = -# 3927 "src/ocaml/preprocess/parser_raw.mly" +# 4123 "src/ocaml/preprocess/parser_raw.mly" ( Private ) -# 44518 "src/ocaml/preprocess/parser_raw.ml" +# 52901 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44576,27 +52959,27 @@ module Tables = struct let xs = # 253 "" ( List.rev xs ) -# 44580 "src/ocaml/preprocess/parser_raw.ml" +# 52963 "src/ocaml/preprocess/parser_raw.ml" in -# 1074 "src/ocaml/preprocess/parser_raw.mly" +# 1111 "src/ocaml/preprocess/parser_raw.mly" ( xs ) -# 44585 "src/ocaml/preprocess/parser_raw.ml" +# 52968 "src/ocaml/preprocess/parser_raw.ml" in -# 3157 "src/ocaml/preprocess/parser_raw.mly" +# 3297 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 44591 "src/ocaml/preprocess/parser_raw.ml" +# 52974 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__6_ = _endpos_xs_ in let _5 = let _1 = _1_inlined2 in -# 3481 "src/ocaml/preprocess/parser_raw.mly" +# 3621 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 44600 "src/ocaml/preprocess/parser_raw.ml" +# 52983 "src/ocaml/preprocess/parser_raw.ml" in let _3 = @@ -44605,16 +52988,16 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 44611 "src/ocaml/preprocess/parser_raw.ml" +# 52994 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__6_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3400 "src/ocaml/preprocess/parser_raw.mly" +# 3540 "src/ocaml/preprocess/parser_raw.mly" ( let lident = loc_last _3 in Pwith_type (_3, @@ -44624,7 +53007,7 @@ module Tables = struct ~manifest:_5 ~priv:_4 ~loc:(make_loc _sloc))) ) -# 44628 "src/ocaml/preprocess/parser_raw.ml" +# 53011 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44677,9 +53060,9 @@ module Tables = struct let _v : (Parsetree.with_constraint) = let _5 = let _1 = _1_inlined2 in -# 3481 "src/ocaml/preprocess/parser_raw.mly" +# 3621 "src/ocaml/preprocess/parser_raw.mly" ( _1 ) -# 44683 "src/ocaml/preprocess/parser_raw.ml" +# 53066 "src/ocaml/preprocess/parser_raw.ml" in let _endpos__5_ = _endpos__1_inlined2_ in @@ -44689,16 +53072,16 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 44695 "src/ocaml/preprocess/parser_raw.ml" +# 53078 "src/ocaml/preprocess/parser_raw.ml" in let _endpos = _endpos__5_ in let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 3413 "src/ocaml/preprocess/parser_raw.mly" +# 3553 "src/ocaml/preprocess/parser_raw.mly" ( let lident = loc_last _3 in Pwith_typesubst (_3, @@ -44706,7 +53089,7 @@ module Tables = struct ~params:_2 ~manifest:_5 ~loc:(make_loc _sloc))) ) -# 44710 "src/ocaml/preprocess/parser_raw.ml" +# 53093 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44755,9 +53138,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 44761 "src/ocaml/preprocess/parser_raw.ml" +# 53144 "src/ocaml/preprocess/parser_raw.ml" in let _2 = @@ -44766,15 +53149,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 44772 "src/ocaml/preprocess/parser_raw.ml" +# 53155 "src/ocaml/preprocess/parser_raw.ml" in -# 3421 "src/ocaml/preprocess/parser_raw.mly" +# 3561 "src/ocaml/preprocess/parser_raw.mly" ( Pwith_module (_2, _4) ) -# 44778 "src/ocaml/preprocess/parser_raw.ml" +# 53161 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44823,9 +53206,9 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 44829 "src/ocaml/preprocess/parser_raw.ml" +# 53212 "src/ocaml/preprocess/parser_raw.ml" in let _2 = @@ -44834,15 +53217,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 44840 "src/ocaml/preprocess/parser_raw.ml" +# 53223 "src/ocaml/preprocess/parser_raw.ml" in -# 3423 "src/ocaml/preprocess/parser_raw.mly" +# 3563 "src/ocaml/preprocess/parser_raw.mly" ( Pwith_modsubst (_2, _4) ) -# 44846 "src/ocaml/preprocess/parser_raw.ml" +# 53229 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44898,15 +53281,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 44904 "src/ocaml/preprocess/parser_raw.ml" +# 53287 "src/ocaml/preprocess/parser_raw.ml" in -# 3425 "src/ocaml/preprocess/parser_raw.mly" +# 3565 "src/ocaml/preprocess/parser_raw.mly" ( Pwith_modtype (l, rhs) ) -# 44910 "src/ocaml/preprocess/parser_raw.ml" +# 53293 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44962,15 +53345,15 @@ module Tables = struct let _symbolstartpos = _startpos__1_ in let _sloc = (_symbolstartpos, _endpos) in -# 990 "src/ocaml/preprocess/parser_raw.mly" +# 1027 "src/ocaml/preprocess/parser_raw.mly" ( mkrhs _1 _sloc ) -# 44968 "src/ocaml/preprocess/parser_raw.ml" +# 53351 "src/ocaml/preprocess/parser_raw.ml" in -# 3427 "src/ocaml/preprocess/parser_raw.mly" +# 3567 "src/ocaml/preprocess/parser_raw.mly" ( Pwith_modtypesubst (l, rhs) ) -# 44974 "src/ocaml/preprocess/parser_raw.ml" +# 53357 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -44993,9 +53376,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : (Asttypes.private_flag) = -# 3430 "src/ocaml/preprocess/parser_raw.mly" +# 3570 "src/ocaml/preprocess/parser_raw.mly" ( Public ) -# 44999 "src/ocaml/preprocess/parser_raw.ml" +# 53382 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45025,9 +53408,9 @@ module Tables = struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : (Asttypes.private_flag) = -# 3431 "src/ocaml/preprocess/parser_raw.mly" +# 3571 "src/ocaml/preprocess/parser_raw.mly" ( Private ) -# 45031 "src/ocaml/preprocess/parser_raw.ml" +# 53414 "src/ocaml/preprocess/parser_raw.ml" in { MenhirLib.EngineTypes.state = _menhir_s; @@ -45056,19 +53439,17 @@ module MenhirInterpreter = struct type _ terminal = | T_error : unit terminal | T_WITH : unit terminal - | T_WHILE_LWT : unit terminal | T_WHILE : unit terminal | T_WHEN : unit terminal | T_VIRTUAL : unit terminal | T_VAL : unit terminal | T_UNDERSCORE : unit terminal | T_UIDENT : ( -# 845 "src/ocaml/preprocess/parser_raw.mly" +# 890 "src/ocaml/preprocess/parser_raw.mly" (string) -# 45069 "src/ocaml/preprocess/parser_raw.ml" +# 53451 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_TYPE : unit terminal - | T_TRY_LWT : unit terminal | T_TRY : unit terminal | T_TRUE : unit terminal | T_TO : unit terminal @@ -45076,9 +53457,9 @@ module MenhirInterpreter = struct | T_THEN : unit terminal | T_STRUCT : unit terminal | T_STRING : ( -# 831 "src/ocaml/preprocess/parser_raw.mly" +# 876 "src/ocaml/preprocess/parser_raw.mly" (string * Location.t * string option) -# 45082 "src/ocaml/preprocess/parser_raw.ml" +# 53463 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_STAR : unit terminal | T_SIG : unit terminal @@ -45089,22 +53470,22 @@ module MenhirInterpreter = struct | T_RBRACKET : unit terminal | T_RBRACE : unit terminal | T_QUOTED_STRING_ITEM : ( -# 836 "src/ocaml/preprocess/parser_raw.mly" +# 881 "src/ocaml/preprocess/parser_raw.mly" (string * Location.t * string * Location.t * string option) -# 45095 "src/ocaml/preprocess/parser_raw.ml" +# 53476 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_QUOTED_STRING_EXPR : ( -# 833 "src/ocaml/preprocess/parser_raw.mly" +# 878 "src/ocaml/preprocess/parser_raw.mly" (string * Location.t * string * Location.t * string option) -# 45100 "src/ocaml/preprocess/parser_raw.ml" +# 53481 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_QUOTE : unit terminal | T_QUESTION : unit terminal | T_PRIVATE : unit terminal | T_PREFIXOP : ( -# 817 "src/ocaml/preprocess/parser_raw.mly" +# 862 "src/ocaml/preprocess/parser_raw.mly" (string) -# 45108 "src/ocaml/preprocess/parser_raw.ml" +# 53489 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_PLUSEQ : unit terminal | T_PLUSDOT : unit terminal @@ -45112,9 +53493,9 @@ module MenhirInterpreter = struct | T_PERCENT : unit terminal | T_OR : unit terminal | T_OPTLABEL : ( -# 810 "src/ocaml/preprocess/parser_raw.mly" +# 855 "src/ocaml/preprocess/parser_raw.mly" (string) -# 45118 "src/ocaml/preprocess/parser_raw.ml" +# 53499 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_OPEN : unit terminal | T_OF : unit terminal @@ -45127,19 +53508,17 @@ module MenhirInterpreter = struct | T_MINUSDOT : unit terminal | T_MINUS : unit terminal | T_METHOD : unit terminal - | T_MATCH_LWT : unit terminal | T_MATCH : unit terminal | T_LPAREN : unit terminal | T_LIDENT : ( -# 793 "src/ocaml/preprocess/parser_raw.mly" +# 838 "src/ocaml/preprocess/parser_raw.mly" (string) -# 45137 "src/ocaml/preprocess/parser_raw.ml" +# 53517 "src/ocaml/preprocess/parser_raw.ml" ) terminal - | T_LET_LWT : unit terminal | T_LETOP : ( -# 775 "src/ocaml/preprocess/parser_raw.mly" +# 820 "src/ocaml/preprocess/parser_raw.mly" (string) -# 45143 "src/ocaml/preprocess/parser_raw.ml" +# 53522 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_LET : unit terminal | T_LESSMINUS : unit terminal @@ -45157,49 +53536,49 @@ module MenhirInterpreter = struct | T_LBRACE : unit terminal | T_LAZY : unit terminal | T_LABEL : ( -# 780 "src/ocaml/preprocess/parser_raw.mly" +# 825 "src/ocaml/preprocess/parser_raw.mly" (string) -# 45163 "src/ocaml/preprocess/parser_raw.ml" +# 53542 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_INT : ( -# 779 "src/ocaml/preprocess/parser_raw.mly" +# 824 "src/ocaml/preprocess/parser_raw.mly" (string * char option) -# 45168 "src/ocaml/preprocess/parser_raw.ml" +# 53547 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_INITIALIZER : unit terminal | T_INHERIT : unit terminal | T_INFIXOP4 : ( -# 773 "src/ocaml/preprocess/parser_raw.mly" +# 818 "src/ocaml/preprocess/parser_raw.mly" (string) -# 45175 "src/ocaml/preprocess/parser_raw.ml" +# 53554 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_INFIXOP3 : ( -# 772 "src/ocaml/preprocess/parser_raw.mly" +# 817 "src/ocaml/preprocess/parser_raw.mly" (string) -# 45180 "src/ocaml/preprocess/parser_raw.ml" +# 53559 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_INFIXOP2 : ( -# 771 "src/ocaml/preprocess/parser_raw.mly" +# 816 "src/ocaml/preprocess/parser_raw.mly" (string) -# 45185 "src/ocaml/preprocess/parser_raw.ml" +# 53564 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_INFIXOP1 : ( -# 770 "src/ocaml/preprocess/parser_raw.mly" +# 815 "src/ocaml/preprocess/parser_raw.mly" (string) -# 45190 "src/ocaml/preprocess/parser_raw.ml" +# 53569 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_INFIXOP0 : ( -# 769 "src/ocaml/preprocess/parser_raw.mly" +# 814 "src/ocaml/preprocess/parser_raw.mly" (string) -# 45195 "src/ocaml/preprocess/parser_raw.ml" +# 53574 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_INCLUDE : unit terminal | T_IN : unit terminal | T_IF : unit terminal | T_HASHOP : ( -# 828 "src/ocaml/preprocess/parser_raw.mly" +# 873 "src/ocaml/preprocess/parser_raw.mly" (string) -# 45203 "src/ocaml/preprocess/parser_raw.ml" +# 53582 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_HASH : unit terminal | T_GREATERRBRACKET : unit terminal @@ -45209,14 +53588,12 @@ module MenhirInterpreter = struct | T_FUNCTOR : unit terminal | T_FUNCTION : unit terminal | T_FUN : unit terminal - | T_FOR_LWT : unit terminal | T_FOR : unit terminal | T_FLOAT : ( -# 758 "src/ocaml/preprocess/parser_raw.mly" +# 803 "src/ocaml/preprocess/parser_raw.mly" (string * char option) -# 45218 "src/ocaml/preprocess/parser_raw.ml" +# 53596 "src/ocaml/preprocess/parser_raw.ml" ) terminal - | T_FINALLY_LWT : unit terminal | T_FALSE : unit terminal | T_EXTERNAL : unit terminal | T_EXCEPTION : unit terminal @@ -45228,25 +53605,25 @@ module MenhirInterpreter = struct | T_DOWNTO : unit terminal | T_DOTTILDE : unit terminal | T_DOTOP : ( -# 774 "src/ocaml/preprocess/parser_raw.mly" +# 819 "src/ocaml/preprocess/parser_raw.mly" (string) -# 45234 "src/ocaml/preprocess/parser_raw.ml" +# 53611 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_DOTLESS : unit terminal | T_DOTDOT : unit terminal | T_DOT : unit terminal | T_DONE : unit terminal | T_DOCSTRING : ( -# 853 "src/ocaml/preprocess/parser_raw.mly" +# 898 "src/ocaml/preprocess/parser_raw.mly" (Docstrings.docstring) -# 45243 "src/ocaml/preprocess/parser_raw.ml" +# 53620 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_DO : unit terminal | T_CONSTRAINT : unit terminal | T_COMMENT : ( -# 852 "src/ocaml/preprocess/parser_raw.mly" +# 897 "src/ocaml/preprocess/parser_raw.mly" (string * Location.t) -# 45250 "src/ocaml/preprocess/parser_raw.ml" +# 53627 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_COMMA : unit terminal | T_COLONGREATER : unit terminal @@ -45255,9 +53632,9 @@ module MenhirInterpreter = struct | T_COLON : unit terminal | T_CLASS : unit terminal | T_CHAR : ( -# 738 "src/ocaml/preprocess/parser_raw.mly" +# 783 "src/ocaml/preprocess/parser_raw.mly" (char) -# 45261 "src/ocaml/preprocess/parser_raw.ml" +# 53638 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_BEGIN : unit terminal | T_BARRBRACKET : unit terminal @@ -45268,9 +53645,9 @@ module MenhirInterpreter = struct | T_ASSERT : unit terminal | T_AS : unit terminal | T_ANDOP : ( -# 776 "src/ocaml/preprocess/parser_raw.mly" +# 821 "src/ocaml/preprocess/parser_raw.mly" (string) -# 45274 "src/ocaml/preprocess/parser_raw.ml" +# 53651 "src/ocaml/preprocess/parser_raw.ml" ) terminal | T_AND : unit terminal | T_AMPERSAND : unit terminal @@ -45295,7 +53672,7 @@ module MenhirInterpreter = struct | N_type_parameter : (Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) nonterminal | N_type_longident : (Longident.t) nonterminal | N_type_kind : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) nonterminal - | N_type_constraint : (Parsetree.core_type option * Parsetree.core_type option) nonterminal + | N_type_constraint : (Parsetree.type_constraint) nonterminal | N_tuple_type : (Parsetree.core_type) nonterminal | N_toplevel_phrase : (Parsetree.toplevel_phrase) nonterminal | N_toplevel_directive : (Parsetree.toplevel_phrase) nonterminal @@ -45334,6 +53711,7 @@ module MenhirInterpreter = struct | N_reversed_nonempty_llist_name_tag_ : (string list) nonterminal | N_reversed_nonempty_llist_labeled_simple_expr_ : ((Asttypes.arg_label * Parsetree.expression) list) nonterminal | N_reversed_nonempty_llist_functor_arg_ : ((Lexing.position * Parsetree.functor_parameter) list) nonterminal + | N_reversed_nonempty_concat_fun_param_as_list_ : (Parsetree.function_param list) nonterminal | N_reversed_llist_preceded_CONSTRAINT_constrain__ : ((Parsetree.core_type * Parsetree.core_type * Location.t) list) nonterminal | N_reversed_bar_llist_extension_constructor_declaration_ : (Parsetree.extension_constructor list) nonterminal | N_reversed_bar_llist_extension_constructor_ : (Parsetree.extension_constructor list) nonterminal @@ -45367,12 +53745,13 @@ module MenhirInterpreter = struct | N_parse_any_longident : (Longident.t) nonterminal | N_paren_module_expr : (Parsetree.module_expr) nonterminal | N_optlabel : (string) nonterminal - | N_option_type_constraint_ : ((Parsetree.core_type option * Parsetree.core_type option) option) nonterminal + | N_option_type_constraint_ : (Parsetree.type_constraint option) nonterminal | N_option_preceded_EQUAL_seq_expr__ : (Parsetree.expression option) nonterminal | N_option_preceded_EQUAL_pattern__ : (Parsetree.pattern option) nonterminal | N_option_preceded_EQUAL_module_type__ : (Parsetree.module_type option) nonterminal | N_option_preceded_EQUAL_expr__ : (Parsetree.expression option) nonterminal | N_option_preceded_COLON_core_type__ : (Parsetree.core_type option) nonterminal + | N_option_preceded_COLON_atomic_type__ : (Parsetree.core_type option) nonterminal | N_option_preceded_AS_mkrhs_LIDENT___ : (string Location.loc option) nonterminal | N_option_SEMI_ : (unit option) nonterminal | N_option_BAR_ : (unit option) nonterminal @@ -45380,6 +53759,7 @@ module MenhirInterpreter = struct | N_operator : (string) nonterminal | N_open_description : (Longident.t Location.loc Parsetree.open_infos * string Location.loc option) nonterminal | N_open_declaration : (Parsetree.module_expr Parsetree.open_infos * string Location.loc option) nonterminal + | N_object_type : (Parsetree.core_type) nonterminal | N_nonempty_type_kind : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) nonterminal | N_nonempty_list_raw_string_ : (string list) nonterminal | N_nonempty_list_mkrhs_LIDENT__ : (string Location.loc list) nonterminal @@ -45401,15 +53781,13 @@ module MenhirInterpreter = struct | N_mk_longident_mod_longident_UIDENT_ : (Longident.t) nonterminal | N_mk_longident_mod_longident_LIDENT_ : (Longident.t) nonterminal | N_mk_longident_mod_ext_longident_ident_ : (Longident.t) nonterminal - | N_mk_longident_mod_ext_longident___anonymous_41_ : (Longident.t) nonterminal + | N_mk_longident_mod_ext_longident___anonymous_43_ : (Longident.t) nonterminal | N_mk_longident_mod_ext_longident_UIDENT_ : (Longident.t) nonterminal | N_mk_longident_mod_ext_longident_LIDENT_ : (Longident.t) nonterminal | N_method_ : ((string Location.loc * Asttypes.private_flag * Parsetree.class_field_kind) * Parsetree.attributes) nonterminal | N_meth_list : (Parsetree.object_field list * Asttypes.closed_flag) nonterminal | N_match_case : (Parsetree.case) nonterminal - | N_lwt_bindings : (Ast_helper.let_bindings) nonterminal - | N_lwt_binding : (Ast_helper.let_bindings) nonterminal | N_listx_SEMI_record_pat_field_UNDERSCORE_ : ((Longident.t Location.loc * Parsetree.pattern) list * unit option) nonterminal | N_list_use_file_element_ : (Parsetree.toplevel_phrase list list) nonterminal | N_list_text_str_structure_item__ : (Parsetree.structure_item list list) nonterminal @@ -45431,8 +53809,10 @@ module MenhirInterpreter = struct | N_let_pattern : (Parsetree.pattern) nonterminal | N_let_bindings_no_ext_ : (Ast_helper.let_bindings) nonterminal | N_let_bindings_ext_ : (Ast_helper.let_bindings) nonterminal - | N_let_binding_body_no_punning : (Parsetree.pattern * Parsetree.expression) nonterminal - | N_let_binding_body : (Parsetree.pattern * Parsetree.expression * bool) nonterminal + | N_let_binding_body_no_punning : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option) nonterminal + | N_let_binding_body : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option * bool) nonterminal | N_labeled_simple_pattern : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) nonterminal | N_labeled_simple_expr : (Asttypes.arg_label * Parsetree.expression) nonterminal | N_label_longident : (Longident.t) nonterminal @@ -45460,16 +53840,21 @@ module MenhirInterpreter = struct | N_functor_args : ((Lexing.position * Parsetree.functor_parameter) list) nonterminal | N_functor_arg : (Lexing.position * Parsetree.functor_parameter) nonterminal | N_function_type : (Parsetree.core_type) nonterminal - | N_fun_def : (Parsetree.expression) nonterminal - | N_fun_binding : (Parsetree.expression) nonterminal + | N_fun_seq_expr : (Parsetree.expression) nonterminal + | N_fun_params : (Parsetree.function_param list) nonterminal + | N_fun_param_as_list : (Parsetree.function_param list) nonterminal + | N_fun_expr : (Parsetree.expression) nonterminal + | N_fun_body : (Parsetree.function_body) nonterminal | N_formal_class_parameters : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) nonterminal | N_floating_attribute : (Parsetree.attribute) nonterminal + | N_extension_type : (Parsetree.core_type) nonterminal | N_extension_constructor_rebind_epsilon_ : (Parsetree.extension_constructor) nonterminal | N_extension_constructor_rebind_BAR_ : (Parsetree.extension_constructor) nonterminal | N_extension : (Parsetree.extension) nonterminal | N_ext : (string Location.loc option) nonterminal - | N_expr : (Parsetree.expression) nonterminal | N_direction_flag : (Asttypes.direction_flag) nonterminal + | N_delimited_type_supporting_local_open : (Parsetree.core_type) nonterminal + | N_delimited_type : (Parsetree.core_type) nonterminal | N_core_type : (Parsetree.core_type) nonterminal | N_constructor_declarations : (Parsetree.constructor_declaration list) nonterminal | N_constructor_arguments : (Parsetree.constructor_arguments) nonterminal @@ -45492,6 +53877,7 @@ module MenhirInterpreter = struct | N_class_field : (Parsetree.class_field) nonterminal | N_class_expr : (Parsetree.class_expr) nonterminal | N_attribute : (Parsetree.attribute) nonterminal + | N_attr_payload : (Parsetree.payload) nonterminal | N_attr_id : (string Location.loc) nonterminal | N_atomic_type : (Parsetree.core_type) nonterminal | N_any_longident : (Longident.t) nonterminal @@ -45519,266 +53905,254 @@ module MenhirInterpreter = struct | 1 -> X (T T_WITH) | 2 -> - X (T T_WHILE_LWT) - | 3 -> X (T T_WHILE) - | 4 -> + | 3 -> X (T T_WHEN) - | 5 -> + | 4 -> X (T T_VIRTUAL) - | 6 -> + | 5 -> X (T T_VAL) - | 7 -> + | 6 -> X (T T_UNDERSCORE) - | 8 -> + | 7 -> X (T T_UIDENT) - | 9 -> + | 8 -> X (T T_TYPE) - | 10 -> - X (T T_TRY_LWT) - | 11 -> + | 9 -> X (T T_TRY) - | 12 -> + | 10 -> X (T T_TRUE) - | 13 -> + | 11 -> X (T T_TO) - | 14 -> + | 12 -> X (T T_TILDE) - | 15 -> + | 13 -> X (T T_THEN) - | 16 -> + | 14 -> X (T T_STRUCT) - | 17 -> + | 15 -> X (T T_STRING) - | 18 -> + | 16 -> X (T T_STAR) - | 19 -> + | 17 -> X (T T_SIG) - | 20 -> + | 18 -> X (T T_SEMISEMI) - | 21 -> + | 19 -> X (T T_SEMI) - | 22 -> + | 20 -> X (T T_RPAREN) - | 23 -> + | 21 -> X (T T_REC) - | 24 -> + | 22 -> X (T T_RBRACKET) - | 25 -> + | 23 -> X (T T_RBRACE) - | 26 -> + | 24 -> X (T T_QUOTED_STRING_ITEM) - | 27 -> + | 25 -> X (T T_QUOTED_STRING_EXPR) - | 28 -> + | 26 -> X (T T_QUOTE) - | 29 -> + | 27 -> X (T T_QUESTION) - | 30 -> + | 28 -> X (T T_PRIVATE) - | 31 -> + | 29 -> X (T T_PREFIXOP) - | 32 -> + | 30 -> X (T T_PLUSEQ) - | 33 -> + | 31 -> X (T T_PLUSDOT) - | 34 -> + | 32 -> X (T T_PLUS) - | 35 -> + | 33 -> X (T T_PERCENT) - | 36 -> + | 34 -> X (T T_OR) - | 37 -> + | 35 -> X (T T_OPTLABEL) - | 38 -> + | 36 -> X (T T_OPEN) - | 39 -> + | 37 -> X (T T_OF) - | 40 -> + | 38 -> X (T T_OBJECT) - | 41 -> + | 39 -> X (T T_NONREC) - | 42 -> + | 40 -> X (T T_NEW) - | 43 -> + | 41 -> X (T T_MUTABLE) - | 44 -> + | 42 -> X (T T_MODULE) - | 45 -> + | 43 -> X (T T_MINUSGREATER) - | 46 -> + | 44 -> X (T T_MINUSDOT) - | 47 -> + | 45 -> X (T T_MINUS) - | 48 -> + | 46 -> X (T T_METHOD) - | 49 -> - X (T T_MATCH_LWT) - | 50 -> + | 47 -> X (T T_MATCH) - | 51 -> + | 48 -> X (T T_LPAREN) - | 52 -> + | 49 -> X (T T_LIDENT) - | 53 -> - X (T T_LET_LWT) - | 54 -> + | 50 -> X (T T_LETOP) - | 55 -> + | 51 -> X (T T_LET) - | 56 -> + | 52 -> X (T T_LESSMINUS) - | 57 -> + | 53 -> X (T T_LESS) - | 58 -> + | 54 -> X (T T_LBRACKETPERCENTPERCENT) - | 59 -> + | 55 -> X (T T_LBRACKETPERCENT) - | 60 -> + | 56 -> X (T T_LBRACKETLESS) - | 61 -> + | 57 -> X (T T_LBRACKETGREATER) - | 62 -> + | 58 -> X (T T_LBRACKETBAR) - | 63 -> + | 59 -> X (T T_LBRACKETATATAT) - | 64 -> + | 60 -> X (T T_LBRACKETATAT) - | 65 -> + | 61 -> X (T T_LBRACKETAT) - | 66 -> + | 62 -> X (T T_LBRACKET) - | 67 -> + | 63 -> X (T T_LBRACELESS) - | 68 -> + | 64 -> X (T T_LBRACE) - | 69 -> + | 65 -> X (T T_LAZY) - | 70 -> + | 66 -> X (T T_LABEL) - | 71 -> + | 67 -> X (T T_INT) - | 72 -> + | 68 -> X (T T_INITIALIZER) - | 73 -> + | 69 -> X (T T_INHERIT) - | 74 -> + | 70 -> X (T T_INFIXOP4) - | 75 -> + | 71 -> X (T T_INFIXOP3) - | 76 -> + | 72 -> X (T T_INFIXOP2) - | 77 -> + | 73 -> X (T T_INFIXOP1) - | 78 -> + | 74 -> X (T T_INFIXOP0) - | 79 -> + | 75 -> X (T T_INCLUDE) - | 80 -> + | 76 -> X (T T_IN) - | 81 -> + | 77 -> X (T T_IF) - | 82 -> + | 78 -> X (T T_HASHOP) - | 83 -> + | 79 -> X (T T_HASH) - | 84 -> + | 80 -> X (T T_GREATERRBRACKET) - | 85 -> + | 81 -> X (T T_GREATERRBRACE) - | 86 -> + | 82 -> X (T T_GREATERDOT) - | 87 -> + | 83 -> X (T T_GREATER) - | 88 -> + | 84 -> X (T T_FUNCTOR) - | 89 -> + | 85 -> X (T T_FUNCTION) - | 90 -> + | 86 -> X (T T_FUN) - | 91 -> - X (T T_FOR_LWT) - | 92 -> + | 87 -> X (T T_FOR) - | 93 -> + | 88 -> X (T T_FLOAT) - | 94 -> - X (T T_FINALLY_LWT) - | 95 -> + | 89 -> X (T T_FALSE) - | 96 -> + | 90 -> X (T T_EXTERNAL) - | 97 -> + | 91 -> X (T T_EXCEPTION) - | 98 -> + | 92 -> X (T T_EQUAL) - | 99 -> + | 93 -> X (T T_EOL) - | 100 -> + | 94 -> X (T T_EOF) - | 101 -> + | 95 -> X (T T_END) - | 102 -> + | 96 -> X (T T_ELSE) - | 103 -> + | 97 -> X (T T_DOWNTO) - | 104 -> + | 98 -> X (T T_DOTTILDE) - | 105 -> + | 99 -> X (T T_DOTOP) - | 106 -> + | 100 -> X (T T_DOTLESS) - | 107 -> + | 101 -> X (T T_DOTDOT) - | 108 -> + | 102 -> X (T T_DOT) - | 109 -> + | 103 -> X (T T_DONE) - | 110 -> + | 104 -> X (T T_DOCSTRING) - | 111 -> + | 105 -> X (T T_DO) - | 112 -> + | 106 -> X (T T_CONSTRAINT) - | 113 -> + | 107 -> X (T T_COMMENT) - | 114 -> + | 108 -> X (T T_COMMA) - | 115 -> + | 109 -> X (T T_COLONGREATER) - | 116 -> + | 110 -> X (T T_COLONEQUAL) - | 117 -> + | 111 -> X (T T_COLONCOLON) - | 118 -> + | 112 -> X (T T_COLON) - | 119 -> + | 113 -> X (T T_CLASS) - | 120 -> + | 114 -> X (T T_CHAR) - | 121 -> + | 115 -> X (T T_BEGIN) - | 122 -> + | 116 -> X (T T_BARRBRACKET) - | 123 -> + | 117 -> X (T T_BARBAR) - | 124 -> + | 118 -> X (T T_BAR) - | 125 -> + | 119 -> X (T T_BANG) - | 126 -> + | 120 -> X (T T_BACKQUOTE) - | 127 -> + | 121 -> X (T T_ASSERT) - | 128 -> + | 122 -> X (T T_AS) - | 129 -> + | 123 -> X (T T_ANDOP) - | 130 -> + | 124 -> X (T T_AND) - | 131 -> + | 125 -> X (T T_AMPERSAND) - | 132 -> + | 126 -> X (T T_AMPERAMPER) | _ -> assert false @@ -45786,316 +54160,330 @@ module MenhirInterpreter = struct and nonterminal = fun nt -> match nt with - | 225 -> + | 232 -> X (N N_additive) - | 224 -> + | 231 -> X (N N_alias_type) - | 223 -> + | 230 -> X (N N_and_let_binding) - | 222 -> + | 229 -> X (N N_any_longident) - | 221 -> + | 228 -> X (N N_atomic_type) - | 220 -> + | 227 -> X (N N_attr_id) - | 219 -> + | 226 -> + X (N N_attr_payload) + | 225 -> X (N N_attribute) - | 218 -> + | 224 -> X (N N_class_expr) - | 217 -> + | 223 -> X (N N_class_field) - | 216 -> + | 222 -> X (N N_class_fun_binding) - | 215 -> + | 221 -> X (N N_class_fun_def) - | 214 -> + | 220 -> X (N N_class_longident) - | 213 -> + | 219 -> X (N N_class_self_pattern) - | 212 -> + | 218 -> X (N N_class_self_type) - | 211 -> + | 217 -> X (N N_class_sig_field) - | 210 -> + | 216 -> X (N N_class_signature) - | 209 -> + | 215 -> X (N N_class_simple_expr) - | 208 -> + | 214 -> X (N N_class_type) - | 207 -> + | 213 -> X (N N_class_type_declarations) - | 206 -> + | 212 -> X (N N_clty_longident) - | 205 -> + | 211 -> X (N N_constant) - | 204 -> + | 210 -> X (N N_constr_extra_nonprefix_ident) - | 203 -> + | 209 -> X (N N_constr_ident) - | 202 -> + | 208 -> X (N N_constr_longident) - | 201 -> + | 207 -> X (N N_constrain_field) - | 200 -> + | 206 -> X (N N_constructor_arguments) - | 199 -> + | 205 -> X (N N_constructor_declarations) - | 198 -> + | 204 -> X (N N_core_type) - | 197 -> + | 203 -> + X (N N_delimited_type) + | 202 -> + X (N N_delimited_type_supporting_local_open) + | 201 -> X (N N_direction_flag) + | 200 -> + X (N N_ext) + | 199 -> + X (N N_extension) + | 198 -> + X (N N_extension_constructor_rebind_BAR_) + | 197 -> + X (N N_extension_constructor_rebind_epsilon_) | 196 -> - X (N N_expr) + X (N N_extension_type) | 195 -> - X (N N_ext) + X (N N_floating_attribute) | 194 -> - X (N N_extension) + X (N N_formal_class_parameters) | 193 -> - X (N N_extension_constructor_rebind_BAR_) + X (N N_fun_body) | 192 -> - X (N N_extension_constructor_rebind_epsilon_) + X (N N_fun_expr) | 191 -> - X (N N_floating_attribute) + X (N N_fun_param_as_list) | 190 -> - X (N N_formal_class_parameters) + X (N N_fun_params) | 189 -> - X (N N_fun_binding) + X (N N_fun_seq_expr) | 188 -> - X (N N_fun_def) - | 187 -> X (N N_function_type) - | 186 -> + | 187 -> X (N N_functor_arg) - | 185 -> + | 186 -> X (N N_functor_args) - | 184 -> + | 185 -> X (N N_generalized_constructor_arguments) - | 183 -> + | 184 -> X (N N_generic_constructor_declaration_BAR_) - | 182 -> + | 183 -> X (N N_generic_constructor_declaration_epsilon_) - | 181 -> + | 182 -> X (N N_generic_type_declaration_no_nonrec_flag_type_subst_kind_) - | 180 -> + | 181 -> X (N N_generic_type_declaration_nonrec_flag_type_kind_) - | 179 -> + | 180 -> X (N N_ident) - | 178 -> + | 179 -> X (N N_implementation) - | 177 -> + | 178 -> X (N N_index_mod) - | 176 -> + | 177 -> X (N N_interface) - | 175 -> + | 176 -> X (N N_item_extension) - | 174 -> + | 175 -> X (N N_label_declaration) - | 173 -> + | 174 -> X (N N_label_declaration_semi) - | 172 -> + | 173 -> X (N N_label_declarations) - | 171 -> + | 172 -> X (N N_label_let_pattern) - | 170 -> + | 171 -> X (N N_label_longident) - | 169 -> + | 170 -> X (N N_labeled_simple_expr) - | 168 -> + | 169 -> X (N N_labeled_simple_pattern) - | 167 -> + | 168 -> X (N N_let_binding_body) - | 166 -> + | 167 -> X (N N_let_binding_body_no_punning) - | 165 -> + | 166 -> X (N N_let_bindings_ext_) - | 164 -> + | 165 -> X (N N_let_bindings_no_ext_) - | 163 -> + | 164 -> X (N N_let_pattern) - | 162 -> + | 163 -> X (N N_letop_binding_body) - | 161 -> + | 162 -> X (N N_letop_bindings) - | 160 -> + | 161 -> X (N N_list_and_class_declaration_) - | 159 -> + | 160 -> X (N N_list_and_class_description_) - | 158 -> + | 159 -> X (N N_list_and_class_type_declaration_) - | 157 -> + | 158 -> X (N N_list_and_module_binding_) - | 156 -> + | 157 -> X (N N_list_and_module_declaration_) - | 155 -> + | 156 -> X (N N_list_attribute_) - | 154 -> + | 155 -> X (N N_list_generic_and_type_declaration_type_kind__) - | 153 -> + | 154 -> X (N N_list_generic_and_type_declaration_type_subst_kind__) - | 152 -> + | 153 -> X (N N_list_post_item_attribute_) - | 151 -> + | 152 -> X (N N_list_signature_element_) - | 150 -> + | 151 -> X (N N_list_structure_element_) - | 149 -> + | 150 -> X (N N_list_text_csig_class_sig_field__) - | 148 -> + | 149 -> X (N N_list_text_cstr_class_field__) - | 147 -> + | 148 -> X (N N_list_text_str_structure_item__) - | 146 -> + | 147 -> X (N N_list_use_file_element_) - | 145 -> + | 146 -> X (N N_listx_SEMI_record_pat_field_UNDERSCORE_) + | 145 -> + X (N N_match_case) | 144 -> - X (N N_lwt_binding) + X (N N_meth_list) | 143 -> - X (N N_lwt_bindings) + X (N N_method_) | 142 -> - X (N N_match_case) + X (N N_mk_longident_mod_ext_longident_LIDENT_) | 141 -> - X (N N_meth_list) + X (N N_mk_longident_mod_ext_longident_UIDENT_) | 140 -> - X (N N_method_) + X (N N_mk_longident_mod_ext_longident___anonymous_43_) | 139 -> - X (N N_mk_longident_mod_ext_longident_LIDENT_) + X (N N_mk_longident_mod_ext_longident_ident_) | 138 -> - X (N N_mk_longident_mod_ext_longident_UIDENT_) + X (N N_mk_longident_mod_longident_LIDENT_) | 137 -> - X (N N_mk_longident_mod_ext_longident___anonymous_41_) + X (N N_mk_longident_mod_longident_UIDENT_) | 136 -> - X (N N_mk_longident_mod_ext_longident_ident_) + X (N N_mk_longident_mod_longident_val_ident_) | 135 -> - X (N N_mk_longident_mod_longident_LIDENT_) + X (N N_mod_ext_longident) | 134 -> - X (N N_mk_longident_mod_longident_UIDENT_) + X (N N_mod_longident) | 133 -> - X (N N_mk_longident_mod_longident_val_ident_) + X (N N_module_binding_body) | 132 -> - X (N N_mod_ext_longident) + X (N N_module_declaration_body) | 131 -> - X (N N_mod_longident) + X (N N_module_expr) | 130 -> - X (N N_module_binding_body) + X (N N_module_name) | 129 -> - X (N N_module_declaration_body) + X (N N_module_subst) | 128 -> - X (N N_module_expr) + X (N N_module_type) | 127 -> - X (N N_module_name) + X (N N_module_type_declaration) | 126 -> - X (N N_module_subst) + X (N N_module_type_subst) | 125 -> - X (N N_module_type) + X (N N_mty_longident) | 124 -> - X (N N_module_type_declaration) + X (N N_mutable_flag) | 123 -> - X (N N_module_type_subst) + X (N N_mutable_virtual_flags) | 122 -> - X (N N_mty_longident) + X (N N_name_tag) | 121 -> - X (N N_mutable_flag) + X (N N_nonempty_list_mkrhs_LIDENT__) | 120 -> - X (N N_mutable_virtual_flags) + X (N N_nonempty_list_raw_string_) | 119 -> - X (N N_name_tag) + X (N N_nonempty_type_kind) | 118 -> - X (N N_nonempty_list_mkrhs_LIDENT__) + X (N N_object_type) | 117 -> - X (N N_nonempty_list_raw_string_) + X (N N_open_declaration) | 116 -> - X (N N_nonempty_type_kind) + X (N N_open_description) | 115 -> - X (N N_open_declaration) + X (N N_operator) | 114 -> - X (N N_open_description) + X (N N_opt_ampersand) | 113 -> - X (N N_operator) + X (N N_option_BAR_) | 112 -> - X (N N_opt_ampersand) + X (N N_option_SEMI_) | 111 -> - X (N N_option_BAR_) + X (N N_option_preceded_AS_mkrhs_LIDENT___) | 110 -> - X (N N_option_SEMI_) + X (N N_option_preceded_COLON_atomic_type__) | 109 -> - X (N N_option_preceded_AS_mkrhs_LIDENT___) - | 108 -> X (N N_option_preceded_COLON_core_type__) - | 107 -> + | 108 -> X (N N_option_preceded_EQUAL_expr__) - | 106 -> + | 107 -> X (N N_option_preceded_EQUAL_module_type__) - | 105 -> + | 106 -> X (N N_option_preceded_EQUAL_pattern__) - | 104 -> + | 105 -> X (N N_option_preceded_EQUAL_seq_expr__) - | 103 -> + | 104 -> X (N N_option_type_constraint_) - | 102 -> + | 103 -> X (N N_optlabel) - | 101 -> + | 102 -> X (N N_paren_module_expr) - | 100 -> + | 101 -> X (N N_parse_any_longident) - | 99 -> + | 100 -> X (N N_parse_constr_longident) - | 98 -> + | 99 -> X (N N_parse_core_type) - | 97 -> + | 98 -> X (N N_parse_expression) - | 96 -> + | 97 -> X (N N_parse_mod_ext_longident) - | 95 -> + | 96 -> X (N N_parse_mod_longident) - | 94 -> + | 95 -> X (N N_parse_module_expr) - | 93 -> + | 94 -> X (N N_parse_module_type) - | 92 -> + | 93 -> X (N N_parse_mty_longident) - | 91 -> + | 92 -> X (N N_parse_pattern) - | 90 -> + | 91 -> X (N N_parse_val_longident) - | 89 -> + | 90 -> X (N N_pattern) - | 88 -> + | 89 -> X (N N_pattern_comma_list_pattern_) - | 87 -> + | 88 -> X (N N_pattern_comma_list_pattern_no_exn_) - | 86 -> + | 87 -> X (N N_pattern_gen) - | 85 -> + | 86 -> X (N N_pattern_no_exn) - | 84 -> + | 85 -> X (N N_pattern_var) - | 83 -> + | 84 -> X (N N_payload) - | 82 -> + | 83 -> X (N N_possibly_poly_core_type_) - | 81 -> + | 82 -> X (N N_possibly_poly_core_type_no_attr_) - | 80 -> + | 81 -> X (N N_post_item_attribute) - | 79 -> + | 80 -> X (N N_primitive_declaration) - | 78 -> + | 79 -> X (N N_private_flag) - | 77 -> + | 78 -> X (N N_private_virtual_flags) - | 76 -> + | 77 -> X (N N_rec_flag) - | 75 -> + | 76 -> X (N N_record_expr_content) - | 74 -> + | 75 -> X (N N_reversed_bar_llist_constructor_declaration_) - | 73 -> + | 74 -> X (N N_reversed_bar_llist_extension_constructor_) - | 72 -> + | 73 -> X (N N_reversed_bar_llist_extension_constructor_declaration_) - | 71 -> + | 72 -> X (N N_reversed_llist_preceded_CONSTRAINT_constrain__) + | 71 -> + X (N N_reversed_nonempty_concat_fun_param_as_list_) | 70 -> X (N N_reversed_nonempty_llist_functor_arg_) | 69 -> @@ -46212,22 +54600,22 @@ module MenhirInterpreter = struct assert false and lr0_incoming = - (16, "\000\000\000\006\000H\000\004\000\b\000\n\000\012\000\014\000\018\000\020\000\024\000\026\000\028\000 \000\"\000(\0000\000>\000J\000N\000P\000R\000T\000V\000X\000Z\000b\000f\000j\000p\000\140\000\146\000\148\000\160\000\162\000\164\000\178\000\180\000\182\000\186\000\192\000\194\000\196\000\204\000\206\000\208\000\220\000\224\000\226\000\240\000\244\001\000\001\002\001\006\000U\000\218\001\185\001\185\001\135\000\132\001\185\000\b\001\135\0017\000\016\000\018\000\022\001\135\0017\000\024\001\135\0017\000\026\000$\0008\000@\000R\001\135\0017\000h\000\016\000F\000\144\000\188\000`\000\144\000\188\000h\000&\000.\000@\000B\000D\000F\000H\000J\000Z\001\135\0017\000\016\000\018\000\255\000.\000\238\000\018\000(\0017\000\014\001\135\0017\000h\000F\000^\000`\000n\000t\000\150\000\152\000\154\000\156\000\158\000\166\000\176\000\198\000\212\000h\000,\000\216\001c\000.\000r\000\134\001c\0002\000r\000\138\001c\0004\000r\000\234\000\248\000\252\001\004\001\b\001\n\000\227\000.\000j\000/\000\238\000\016\000\018\000:\000\018\000j\001g\000<\000j\000\238\000L\000h\000:\001g\000Z\001\135\0017\000Z\000\020\000P\0017\000\016\000\"\0017\000\020\001\135\0017\000@\000F\000\252\000T\000`\000\252\000h\000\154\000\252\000F\000`\0005\000\016\000:\001g\0007\000;\000{\000.\000\230\000;\0009\000j\000\198\000\018\000>\000h\000j\000\238\000j\000t\000j\000\238\000x\001\185\000*\0006\000D\000F\000N\000\252\001\135\0017\000h\000\014\0017\000V\001\135\0017\000j\001\007\000\218\000\018\000j\001\r\001\015\001\173\001\183\0017\000^\000`\000d\001\135\0017\000f\001\135\0017\000h\000@\000~\000j\000r\000l\001\135\0017\0000\000\153\000~\000\134\0002\000\138\001\015\001#\0004\001U\000\238\000z\000\250\000\223\000|\0002\000\223\000\134\000\168\001\t\000h\001\t\000.\000\218\000\018\001\021\000\218\000j\001\023\001\157\000\250\000\254\001g\000=\000C\000\\\000s\000&\001\023\001\133\001\187\000\168\001\157\000=\000\205\000C\000\\\001w\001\187\000&\001\187\001w\000I\000q\000\127\0002\000\250\000q\000\239\000P\001\b\000\225\000\131\001\b\001w\001\193\001\002\000:\001g\0017\001\193\0017\001\141\001\183\001\193\000I\0002\000q\000\250\000\127\0002\000\127\0002\000\127\0002\000\176\000\137\0002\000\239\000\239\001\141\000\217\000\198\000\140\001\135\0017\000\144\000\168\000=\000\188\000\192\000\242\000/\0001\000W\000Y\000]\000_\000\216\000_\001\155\000\239\001\007\000\218\000h\000.\000\196\001\135\0017\000Y\000\173\000\177\000\230\000\179\000\230\000\179\000\236\000\179\000\250\000\179\001\002\000/\001\183\000\239\000\179\001\133\001\149\000h\000\020\000j\000\237\000\237\000.\000Y\001\149\001\153\000`\000\236\000.\000\179\000.\000\238\001\141\000.\000\179\000\179\000\236\000.\000\179\000.\000\134\0002\000k\0002\000\179\000,\000k\000]\000\179\000\211\000,\000\016\000,\000\221\001#\000\246\000k\000\246\000/\000\030\000h\000j\000\238\001\141\001W\000.\000j\000<\000h\001W\000\198\000n\000/\000L\000\016\000h\000\179\000\238\001\141\001G\000\209\000.\000j\000\169\000h\000\020\000\237\000.\000\142\000Y\000\198\000p\000N\000\252\001\135\0017\000\178\0017\000h\000.\000\255\000\238\000h\000\178\0017\000\141\001u\001s\000\\\000\245\000\251\000\004\000\020\0009\001U\000\198\000>\000\234\001\193\000\031\001\193\000\143\000\226\001\141\000\198\001\141\000;\000Z\000\020\000\245\000\198\000\251\000\\\000\251\001\183\001\t\000\218\000\018\001g\001\017\001g\001\133\000\234\000\251\001\007\000\198\001\t\000\218\000\234\001\t\000!\000\129\001\006\000!\001u\000\251\000.\000\251\000.\001s\000\\\000\203\001\001\000h\000.\001\001\000.\000\238\000\251\000.\000\203\001\183\001\007\001\133\001\001\000\162\000\134\000\136\000j\000\198\000\138\000j\000\210\000\214\000\140\001\135\0017\000\244\001\135\0017\000\164\001\135\0017\000\180\001\135\0017\000\250\000\179\000\n\000\182\001\135\0017\000h\000\020\000\237\000.\000\\\000\184\001\135\0017\000\179\000\162\000\186\001\135\0017\000\179\000\198\000\252\000-\000/\000[\000\166\000[\000\168\000j\000\212\000h\001\000\001\135\0017\000[\000\218\000h\000K\000[\000\030\000h\000j\000\232\001\141\000\238\001\141\000\232\001\141\000A\000.\000j\000<\000j\000L\000[\000\239\001\007\000\218\000h\000.\000D\000F\000Z\001\135\0017\001\001\000\238\000\251\000.\000^\000`\000n\000Y\000\238\001\141\000\198\000g\000u\000\230\000\239\000[\001\011\001\133\001\149\001\155\001\031\000\162\000g\001!\001K\000\162\000g\001\137\000&\001\137\000B\001\137\000D\001\137\000F\001\137\000H\001\137\000J\001\137\000^\001\137\000`\001\137\000t\001\137\000\150\001\137\000\152\001\137\000\154\001\137\000\156\001\137\000\158\001\137\000\176\001\137\000\198\001\137\000\230\001\137\000\234\001\137\000\236\001\137\000\248\001\137\001\b\001\137\001\n\001\137\001\183\001\149\000[\001\195\001\137\000,\000H\001\185\000g\000g\001\006\0017\000W\000\238\001\141\000\198\000g\000\171\000\198\000g\000\230\000\179\000\236\000\179\000\250\000\179\001\002\000/\001\183\000\173\000\175\000\230\000\179\001M\001O\000\130\001\185\000<\000\179\000\n\000g\000Z\000\020\001\135\0017\001g\000\198\000\251\000\213\000\161\0011\0011\001\135\0017\0000\000\255\000\198\001\001\000\238\000\251\000\198\001\001\001\005\0011\001\006\0017\000\255\001\005\0011\001;\001u\001\005\001;\000\255\001\005\0011\000v\001\185\000\128\001\185\000\160\001\135\0017\001\001\0011\000\194\001\135\0017\000/\000\238\000\135\000:\001g\000\218\001\141\000\165\000\198\000$\000\235\000\235\0011\001\141\000\196\001\135\0017\000\018\000h\000\236\000.\000\134\001\151\000P\000\138\000X\000\243\000j\000\238\000\135\000\218\001\193\000\163\0017\000,\0017\001\193\001Y\0004\001[\001Y\001]\000y\000&\001\187\001\145\001\187\000\198\000h\001\007\000\218\000h\001\149\0017\0011\000\238\000\135\000\218\001\145\000\\\001\187\001\187\001\145\000\\\001\187\001\187\001q\0017\0011\001\153\000\238\000\020\001\135\0017\000T\0009\000j\000\234\000\134\000\138\001Y\0004\000\216\000\250\001\151\001q\0017\000\149\000\250\001o\000\233\000\143\0011\001m\001o\001\141\000\198\000>\000\138\001Y\0004\000\216\001\143\001\151\001q\0017\000\138\001Y\0004\000\216\001\143\001\143\000?\000\143\0011\000=\000B\000>\000\157\000\145\0011\001o\001m\001o\0009\000j\000\234\000\233\000\143\0011\000?\000\143\0011\000=\000B\000\157\000\145\0011\000*\000N\000\252\001\135\0017\001\t\0011\001\135\0017\001\t\0011\000Z\000\020\001\135\0017\001g\000\234\000\251\0011\001\135\0017\000\018\000\234\001\t\0011\0000\000\255\000\238\000\251\0011\001\006\0017\000\255\000\238\000\251\0011\0019\0019\000\255\000\198\001\007\0011\000\238\000\251\001\003\0011\001u\001\003\000\160\001\135\0017\000\251\0011\000\196\001\135\0017\001\151\000\240\000\020\001\135\0017\000\012\000'\000\134\000{\0002\001}\000j\000\198\000R\0017\000h\001\141\000.\001\169\000\014\0017\000\012\000X\000X\000\012\000\241\000j\000\238\001\141\0011\000b\0017\000\012\000>\000>\000\012\000\155\000j\000\238\000\165\0011\000\148\0017\000p\000N\000\252\0017\001\007\000\162\000\134\000}\0002\001\157\000\230\001\141\001\141\001\133\001\157\001\165\001\183\0017\001\007\000\162\001\165\001\165\0011\000\226\0017\001\141\000\198\001\141\001\147\0011\001+\000\204\001_\0011\001\127\001\167\001+\001\165\0011\001\006\0017\000'\001}\000j\000\198\001\165\0011\001=\001=\001\135\0017\000'\001}\000j\000\238\000j\000\238\000C\000\\\000\134\001\141\000C\000\\\000\205\000C\000\\\001\023\001\133\001\161\001\165\001\161\001\161\001\161\0011\001\006\0017\000'\001}\000j\000\238\001\161\0011\001?\001?\000)\000a\000e\000\159\000\229\000\247\000\249\000\253\001/\001_\0011\001i\001\006\0017\0009\000j\000?\000\143\0011\0015\0015\001k\001\006\0017\0009\000j\000\234\000\233\000\143\0011\0013\0013\001\127\001\159\001/\000c\001/\001\141\000\240\001\135\0017\000'\001}\000j\000\198\000R\0017\001\171\000\014\000\252\0017\000\243\000j\000\198\000g\000A\000\198\000g\000+\0011\0017\000\012\000X\000X\000\012\000%\000j\000\238\001\141\000\243\000j\000\198\000g\000A\000\198\000g\000b\000\252\0017\000\157\000j\000\238\000\020\000\237\000\218\001\141\000\198\000g\000\165\000\198\000g\000Q\000Y\001Q\000A\000\198\000g\000Q\001{\001\025\0011\0017\000\012\000>\000>\000\012\000#\000j\000\238\000\165\000\157\000j\000\238\000\020\000\237\000\218\001\141\000\198\000g\000\165\000\198\000g\000Q\000\146\0017\000g\0011\000\148\000\252\0017\000h\000p\000H\001\185\0017\000\153\001O\0011\000N\000\252\0017\001\007\000\162\000\134\000}\0002\001\173\000\182\0017\001Q\000\\\001I\000\162\001\133\001\163\000\142\000[\000[\000\139\001S\001S\001\173\001\181\001\183\001\191\001\181\001\175\001\175\001\181\0017\001\007\000\162\001\181\0017\000\153\001O\0011\001\181\000.\000\238\001\161\000.\001\181\001\002\000j\000\219\0011\0017\001\181\000\219\0011\000\226\0017\001\147\0011\001)\000\204\001_\0011\001\127\001\179\001)\001\181\000\238\001\161\000\198\001\181\001Q\001\177\001\177\0011\001\006\0017\000'\001}\000j\001\177\0011\001A\001A\000)\000M\000p\001\135\0017\000\153\001O\0011\000S\000e\000\159\000\231\000\249\001\031\001\191\001-\001K\001\191\001_\0011\001i\0015\001\127\001\159\000O\000g\0011\001-\000\167\0002\001\031\001-\001K\000\167\0002\000\167\0002\0011\001\137\000\171\000\198\000g\001C\000\162\000g\001\004\001E\001E\000\252\000g\000.\000~\000\246\000o\000\246\001\137\000,\000o\000\134\0002\000o\0002\000\136\000m\000\172\000\138\000[\000\004\000i\001U\000A\000\207\000\215\000,\000i\000i\000\151\0004\001\007\000\218\000j\000/\000\212\000h\000o\000.\000r\001\137\000\134\000o\0002\000r\001\137\000\138\000o\0004\000r\001\137\000\218\000h\000g\000.\000r\001\137\000\134\000g\0002\000r\001\137\000\138\000g\0004\000r\001\137\001\007\000\212\000h\000o\000.\000r\001\137\000\134\000o\0002\000r\001\137\000\138\000o\0004\000r\001\137\001U\000r\001\137\000\139\001\137\000g\000.\000\134\000g\0002\000\138\000g\0004\001\007\000\212\000h\000o\000.\000\134\000o\0002\000\138\000o\0004\001U\000o\000.\000\134\000o\0002\000\138\000o\0004\000g\000\028\000\208\001\139\000g\000\224\000g\000\220\000g\000\224\000g\000\220\000\198\000g\001\139\000g\000\224\000g\000\220\000g\000h\000\020\000\237\000.\000\238\001\187\000\\\000g\001Q\001y\001y\001y\001Q\001y\000g\000\\\000g\000\\\000\218\000g\001\029\000\133\000\250\001\029\001\029\000g\000 \001\137\000\206\001\137\000\204\000g\000\204\000[\001\137\000\174\000[\000\151\0004\001\137\000\215\000,\000m\000\172\000m\000\172\000o\0002\000g\001\135\0017\001\001\000\162\000g\000Z\001\135\0017\000\255\001\005\000\162\000g\000\196\001\135\0017\001\151\001q\0017\000\162\000g\000g\001{\000Q\000g\000\209\000.\000j\000\238\000\020\000\237\000\218\001\141\000\198\000g\000\135\000\218\001\141\000\198\000g\000A\000\198\000g\000Q\001O\0011\001\137\000\246\000o\000\246\000[\000Z\001\135\0017\001\001\000.\000\238\000\251\000.\000g\000.\000A\000.\000g\000\004\000\133\000g\000\004\000\133\001\137\000.\000\232\000\251\000.\000\238\000\251\000.\000\232\000\251\000.\001\001\0011\001\135\0017\001\001\0011\000g\0011\001-\001-\000\167\0002\000\163\0017\000,\0017\000\216\001\027\001\187\000,\001\027\000\176\001\027\000\176\000C\000\\\001w\000w\000.\000\168\001\157\000=\000\230\001\141\001\141\000.\000\230\001\141\000\138\001Y\0004\000\216\001\141\001\143\000\233\000=\000B\000\157\000\250\001\151\000\198\001\149\0017\000\147\0011\001o\001\131\001m\001o\001\129\001\131\001\151\000\198\001\149\0017\0009\000j\000=\000B\000\157\000\147\0011\000O\000\204\001\001\000\251\000.\000\165\0011\000c\000\204\000\251\000.\000\179\000.\000\238\001\141\000.\001\171\001)\000\204\000g\000\004\000\133\000g\000\004\000\133\000\190\000g\000\190\000g\000g\000\224\000g\000\220\000\167\0002\0017\000g\000\224\000g\000\220\000O\000\202\001e\000\000\000c\000\202\001a\000\000\000h\000\236\000.\0001\000\201\001\t\000\218\000h\000\236\000.\0001\001g\001\019\001g\001\153\001\189\000\202\000\000\000\199\001\149\000\202\000\000\000\197\001\141\000\202\000\000\000g\000\202\000\195\000\000\000\193\001\t\000\202\000\000\000\191\001\007\000\202\000\000\000\189\001\001\000\202\000\000\000\187\000\251\000\202\000\000\000\185\000\245\000\202\000\000\000\179\000\202\000\183\000\000\000-\000\202\000\181\001\007\000\218\000\000\000\168\001g\000\026\000$\000\144\000\192\000-\001\007\000\202\000E\000G\000*\000M\001'\000g\0011\000*\001'\000*\000\000\000*\000G\000M\001%\001%\000g\0011\001%\001%\0003\000g\0011\001%\000\202\001%\000\202") + (16, "\000\000\000\006\000D\000\004\000\006\000\b\000\n\000\012\000\016\000\018\000\020\000\022\000\024\000\028\000\030\000$\000,\000:\000F\000J\000L\000N\000P\000R\000T\000V\000^\000`\000d\000h\000\132\000\138\000\140\000\152\000\154\000\156\000\170\000\172\000\174\000\176\000\180\000\182\000\184\000\192\000\194\000\196\000\208\000\212\000\214\000\228\000\232\000\244\000\246\000\250\000U\000\206\001\199\001\199\001\145\000|\001\199\000\012\001\145\0019\000b\000\"\000<\000>\000@\000B\000D\000F\000Z\000\\\000f\000l\000\142\000\144\000\146\000\148\000\150\000\158\000\168\000\186\000\200\000b\000(\000\204\001e\000*\000j\000~\001e\000.\000j\000\130\001e\0000\000j\000\222\000\236\000\240\000\248\000\252\000\254\000\231\000*\000d\000/\000\226\000\014\000\016\0004\0006\000\016\000d\001i\0008\000d\000\226\000H\000b\0006\001i\000V\001\145\0019\000\016\000$\0019\000\018\001\145\0019\000<\000B\000\240\000P\000\\\000\240\000b\000\146\000\240\000B\000\\\0005\000\014\0006\001i\0007\000;\000{\000*\000\218\000;\0009\000d\000\186\000\016\000\022\000:\000b\000*\000d\000\226\000d\000l\000d\000\226\000p\001\199\000\014\000\016\000\018\001\145\0019\000P\0009\000d\000?\000\145\000z\001\199\000\020\001\145\0019\000 \000<\000N\001\145\0019\000b\000\014\000B\000\136\000\178\000\\\000\136\000\178\000b\000B\000V\001\145\0019\000\014\000\016\001\005\000*\000\226\000V\000\018\000L\0019\000\014\000\030\0019\000&\0002\000@\000B\000J\000\240\001\145\0019\000b\000\012\0019\000R\001\145\0019\000d\001\r\000\206\000\016\000d\001\019\001\021\001\185\001\195\0019\000Z\000\\\000`\001\145\0019\000b\000<\000v\000d\000j\000f\000v\000~\000.\000\130\001\021\001%\0000\001W\000\226\000r\000\238\000\227\000t\000.\000\227\000~\000\160\001\015\000b\001\015\000*\000\206\000\016\001\027\000\206\000d\001\029\001\169\000\238\000\242\001i\000=\000C\000X\000s\000\"\000\237\001\015\000\206\000b\000\207\000C\000X\001\029\001y\001\137\001\143\001\149\001\151\001\201\000\"\001\201\000\160\001\169\000=\001y\001\153\000*\001\195\001\207\000\246\0006\001i\001\149\001\201\001y\000I\000q\000\127\000.\000\238\000q\000\245\000L\000\252\000\229\000\131\000\252\001\207\0019\001\207\0019\001\153\000I\000.\000q\000\238\000\127\000.\000\127\000.\000\127\000.\000\168\000\137\000.\000\245\000\245\001\153\000\219\000\186\000\132\001\145\0019\000\136\000\160\000=\000\178\000\180\000\230\000/\0001\000W\000Y\000]\000_\000\204\000_\001\167\000\245\001\r\000\206\000b\000*\000\184\001\145\0019\000Y\000\175\000\179\000\218\000\181\000\218\000\181\000\224\000\181\000\238\000\181\000\246\000/\001\195\000\245\000\181\001\143\001\161\000b\000\018\000d\000\243\000\243\000*\000Y\001\161\001\165\000\\\000\224\000*\000\181\000*\000\226\001\153\000*\000\181\000\181\000\224\000*\000\181\000*\000~\000.\000k\000.\000\181\000(\000k\000]\000\181\000\213\000(\000\014\000(\000\225\001%\000\234\000k\000\234\000/\000\026\000b\000d\000\226\001\153\001Y\000*\000d\0008\000b\001Y\000\186\000h\000J\000\240\001\145\0019\000\170\0019\000b\000*\001\005\000\226\000b\000*\000X\000\170\0019\000\141\001w\001u\000X\000\251\001\001\000\004\000\018\0009\001W\000\186\000:\000\222\001\207\000\031\001\207\000\145\000\214\001\153\000\186\001\153\000;\000V\000\018\000\251\000\186\001\001\000X\001\001\001\195\001\015\000\206\000\016\001i\001\023\001i\001\143\000\222\001\001\001\r\000\186\001\015\000\206\000\222\001\015\000!\000\129\000\250\000!\001w\001\001\001\001\000*\001\001\000*\001u\000X\000\205\001\007\000b\000*\001\007\000*\000\226\001\001\000*\000\205\001\195\001\r\001\143\001\007\000\154\000~\000\128\000d\000\186\000\130\000d\000\198\000\202\000\132\001\145\0019\000\232\001\145\0019\000\156\001\145\0019\000\172\001\145\0019\000\238\000\181\000\b\000\174\001\145\0019\000H\000\014\000b\000\181\000\226\001\153\001I\000\211\000*\000d\000\171\000b\000\018\000\243\000*\000\134\000Y\000Y\000\143\001S\001\127\001}\000\226\001\201\000\221\000X\000\172\001\145\0019\000\133\000\218\000\172\001\145\0019\000\133\000\238\001#\001#\000\176\001\145\0019\000\181\000\186\000\240\000-\000/\000[\000\158\000[\000\160\000d\000\200\000b\000\172\001\145\0019\000\133\000(\000\244\001\145\0019\000[\000\206\000b\000K\000\172\001\145\0019\000\133\000[\000\026\000b\000d\000\220\001\153\000\226\001\153\000\220\001\153\000A\000*\000d\0008\000d\000H\000[\000\245\001\r\000\206\000b\000*\000@\000B\000V\001\145\0019\001\007\000\226\001\001\000*\000Z\000\\\000f\000Y\000\226\001\153\000\186\000g\000u\000\218\000\172\001\145\0019\000\133\000\245\000[\001\017\001\143\001\161\001\167\001M\000\154\000g\001{\001\129\000\"\000\172\001\145\0019\000\133\001\129\000>\000\172\001\145\0019\000\133\001\129\000@\000\172\001\145\0019\000\133\001\129\000B\000\172\001\145\0019\000\133\001\129\000D\000\172\001\145\0019\000\133\001\129\000F\000\172\001\145\0019\000\133\001\129\000Z\000\172\001\145\0019\000\133\001\129\000\\\000\172\001\145\0019\000\133\001\129\000l\000\172\001\145\0019\000\133\001\129\000\142\000\172\001\145\0019\000\133\001\129\000\144\000\172\001\145\0019\000\133\001\129\000\146\000\172\001\145\0019\000\133\001\129\000\148\000\172\001\145\0019\000\133\001\129\000\150\000\172\001\145\0019\000\133\001\129\000\168\000\172\001\145\0019\000\133\001\129\000\186\000\172\001\145\0019\000\133\001\129\000\218\000\172\001\145\0019\000\133\001\129\000\222\000\172\001\145\0019\000\133\001\129\000\224\000\172\001\145\0019\000\133\001\129\000\236\000\172\001\145\0019\000\133\001\129\000\252\000\172\001\145\0019\000\133\001\129\000\254\000\172\001\145\0019\000\133\001\129\001\195\001\161\000[\001\209\000\172\001\145\0019\000\133\001\129\000(\000D\001\199\000g\000g\000\250\0019\000/\000\186\000g\000\226\000\018\000\243\000\206\001\153\000\186\000g\000\135\0006\001i\000\206\001\153\000\186\000g\000A\000\186\000g\000Q\001}\000A\000\209\000\186\001{\001\131\001\127\000W\000\226\001\153\000\186\000g\000\173\000\186\000g\000\218\000\181\000\224\000\181\000\238\000\181\000\246\000/\001\195\000\175\000\177\000\218\000\181\001O\001Q\000\163\0013\0013\001\205\001\129\000\173\000\186\000g\001E\000\154\000g\000\248\001G\001G\000\240\000g\000*\000v\000\234\000o\000\234\001\129\000(\000o\000~\000.\000o\000.\000\128\000m\000\164\000\130\000[\000\004\000i\001W\000\209\000\217\000(\000i\000i\000\153\0000\001\r\000\206\000d\000/\000\134\000[\000\200\000b\000o\000*\000j\000\172\001\145\0019\000\133\001\129\000~\000o\000.\000j\000\172\001\145\0019\000\133\001\129\000\130\000o\0000\000j\000\172\001\145\0019\000\133\001\129\000\206\000b\000g\000*\000j\000\172\001\145\0019\000\133\001\129\000~\000g\000.\000j\000\172\001\145\0019\000\133\001\129\000\130\000g\0000\000j\000\172\001\145\0019\000\133\001\129\001\r\000\200\000b\000o\000*\000j\000\172\001\145\0019\000\133\001\129\000~\000o\000.\000j\000\172\001\145\0019\000\133\001\129\000\130\000o\0000\000j\000\172\001\145\0019\000\133\001\129\001W\000j\000\172\001\145\0019\000\133\001\129\000[\000\139\001U\001U\001\129\000g\000*\000~\000g\000.\000\130\000g\0000\001\r\000\200\000b\000o\000*\000~\000o\000.\000\130\000o\0000\001W\000o\000o\000*\000~\000o\000.\000\130\000o\0000\000g\000\024\000\196\001\147\000g\000\212\000g\000\208\001\129\001\131\000g\000X\000g\000X\000\206\000g\001#\000\133\000g\000\028\000\172\001\145\0019\000\133\000\194\000\172\001\145\0019\000\133\001\129\001\129\000\194\000\172\001\145\0019\000\133\001\129\000\192\000g\000\192\000[\000\172\001\145\0019\000\133\000\166\001\129\000\166\000[\000\153\0000\000\172\001\145\0019\000\133\001\129\000\217\000(\000m\000\164\000m\000\164\000o\000.\000g\001\145\0019\001\007\000\154\000g\000V\001\145\0019\001\005\000\186\001\007\000\226\001\001\000\186\001\007\001\011\000\154\000g\001w\001\011\000\184\001\145\0019\000\016\000b\000\224\000*\000~\001\163\000L\000\130\000T\000\249\000d\000\226\000\135\000\206\001\207\000\165\0019\000(\0019\001\207\001[\0000\001]\001[\001_\000y\000\"\001\201\001\157\001\201\000\226\000\135\000\206\001\157\000X\001\201\001\201\001\157\000X\001\201\001\201\001s\0019\000\154\000g\001\165\001\145\0019\000,\000\155\001Q\0013\000g\000\211\000*\000d\000Q\000\172\001\145\0019\000\133\001\129\000\234\000o\000\234\000[\000V\001\145\0019\001\007\000*\000\226\001\001\000*\000g\000*\000A\000*\000g\000\004\000\133\000\172\001\145\0019\000\133\000*\000\220\001\001\000*\000\226\001\001\000*\000\220\001\001\000*\001\129\000*\000\220\001\001\000*\000\226\001\001\000*\000\220\001\001\000*\001\007\0013\001\145\0019\001\007\0013\000V\000\018\001\145\0019\001i\000\186\001\001\000\215\0013\001\145\0019\000,\001\005\001\011\0013\000\250\0019\001\005\001\011\0013\001=\001=\001\005\001\011\0013\000n\001\199\0008\000\181\000\b\000g\000x\001\199\000\152\001\145\0019\001\007\0013\000\182\001\145\0019\000/\000\226\000\135\000\206\001\153\000\167\000\186\000 \000\241\000\241\0013\001\153\000\184\001\145\0019\001\163\000\186\000b\001\r\000\206\000b\001\161\0019\0013\001s\0019\0013\000\226\000&\000J\000\240\001\145\0019\001\015\0013\001\145\0019\001\015\0013\000V\000\018\001\145\0019\001i\000\222\001\001\0013\001\145\0019\000\016\000\222\001\015\0013\000,\001\005\000\226\001\001\0013\000\250\0019\001\005\000\226\001\001\0013\001;\001;\001\005\000\186\001\r\0013\000\226\001\001\001\t\0013\001w\001\t\000\152\001\145\0019\001\001\0013\000\184\001\145\0019\001\163\000\228\000\018\001\145\0019\000\n\000'\000~\000{\000.\001\133\000d\000\186\000N\0019\000b\001\153\000*\001\181\000\012\0019\000\n\000T\000T\000\n\000\247\000d\000\226\001\153\0013\000^\0019\000\n\000:\000:\000\n\000\157\000d\000\226\000\167\0013\000\140\0019\000h\000J\000\240\0019\001\r\000\154\000~\000}\000.\001\169\000\218\001\153\001\153\001\143\001\169\001\177\001\195\0019\001\r\000\154\001\177\001\177\0013\000\214\0019\001\153\000\186\001\153\001\159\0013\001-\000\192\001a\0013\001\135\001\179\001-\001\177\0013\000\250\0019\000'\001\133\000d\000\186\001\177\0013\001?\001?\001\145\0019\000'\001\133\000d\000\226\000d\000\226\000C\000X\000~\001\153\000C\000X\000\207\000C\000X\001\029\001\143\001\173\001\177\001\173\001\173\001\173\0013\000\250\0019\000'\001\133\000d\000\226\001\173\0013\001A\001A\000)\000a\000e\000\161\000\233\000\253\000\255\001\003\0011\001a\0013\001k\000\250\0019\0009\000d\000?\000\145\0013\0017\0017\001m\000\250\0019\0009\000d\000\222\000~\000\130\001[\0000\000\204\000\238\001\163\001s\0019\000\151\000\238\001q\000\239\000\145\0013\0015\001o\001q\001\153\000\186\000:\000\130\001[\0000\000\204\001\155\001\163\001s\0019\000\130\001[\0000\000\204\001\155\001\155\0015\001\135\001\171\0011\000c\0011\001\153\000\228\001\145\0019\000'\001\133\000d\000\186\000N\0019\001\183\000\012\000\240\0019\000\249\000d\000\186\000g\000A\000\186\000g\000+\0013\0019\000\n\000T\000T\000\n\000%\000d\000\226\001\153\000\249\000d\000\186\000g\000A\000\186\000g\000^\000\240\0019\000:\000\159\000d\000\226\000\018\000\243\000\206\001\153\000\186\000g\000\167\000\186\000g\000Q\001\031\0013\0019\000\n\000:\000:\000\n\000#\000d\000\226\000\167\000\159\000d\000\226\000\018\000\243\000\206\001\153\000\186\000g\000\167\000\186\000g\000Q\000\138\0019\000g\0013\000\140\000\240\0019\000b\000h\000D\001\199\0019\000\155\001Q\0013\000J\000\240\0019\001\r\000\154\000~\000}\000.\001\185\000\174\0019\001S\000X\001K\000\154\001\143\001\175\000\139\001\185\001\193\001\195\001\205\001\193\001\187\001\187\001\193\0019\001\r\000\154\001\193\0019\000\155\001Q\0013\001\193\000*\000\226\001\173\000*\001\193\000\246\000d\000\223\0013\0019\001\193\000\223\0013\000\214\0019\001\159\0013\001+\000\192\001a\0013\001\135\001\191\001+\001\193\000\226\001\173\000\186\001\193\001S\001\189\001\189\0013\000\250\0019\000'\001\133\000d\001\189\0013\001C\001C\000)\000M\000h\000S\000e\000\161\000\235\000\255\001/\001M\001a\0013\001k\0017\001\135\001\171\000O\000g\0013\001/\000\169\001/\001M\001\197\000.\000\169\000.\000g\0013\001/\001/\000O\000\192\001\007\001\001\000*\000\181\000*\000\226\001\153\000*\001\183\001+\000\192\000g\000\004\000\133\001\197\000.\0013\000=\000>\000\159\000\238\001\163\000\186\001\161\0019\000\149\0013\001q\001\141\001o\001q\001\139\001\141\001\163\000\186\001\161\0019\0009\000d\000?\000\145\0013\000=\000>\000\159\000\149\0013\000\169\000.\000\165\0019\000(\0019\000\204\001!\001\201\000(\001!\000\168\001!\000\168\000C\000X\001y\000w\000*\000\160\001\169\000=\000\218\001\153\001\153\000\218\001\153\000\130\001[\0000\000\204\001\153\001\155\000\239\000\222\000\239\000\145\0013\000=\000>\000\159\000\147\0013\001q\001o\001q\0009\000d\000\222\000\239\000\145\0013\000=\000>\000\159\000\147\0013\000c\000\192\001\001\000*\000\167\0013\001\197\000.\0019\000g\000\212\000g\000\208\000O\000\190\001g\000\000\000c\000\190\001c\000\000\000b\000\224\000*\0001\000\203\001\015\000\206\000b\000\224\000*\0001\001i\001\025\001i\001\165\001\203\000\190\000\000\000\201\001\161\000\190\000\000\000\199\001\153\000\190\000\000\000g\000\190\000\197\000\000\000\195\001\015\000\190\000\000\000\193\001\r\000\190\000\000\000\191\001\007\000\190\000\000\000\189\001\001\000\190\000\000\000\187\000\251\000\190\000\000\000\181\000\190\000\185\000\000\000-\000\190\000\183\001\r\000\206\000\000\000\160\001i\000\022\000 \000\136\000\180\000-\001\r\000\190\000E\000G\000&\000M\001)\000g\0013\000&\001)\000&\000\000\000&\000G\000M\001'\001'\000g\0013\001'\001'\0003\000g\0013\001'\000\190\001'\000\190") and rhs = - ((16, "\001e\001a\000\201\000\199\000\197\000\195\000\193\000\191\000\189\000\187\000\185\000\183\000\181\000E\0003\000F\000D\001w\001\193\001\002\000:\001g\001\006\0017\001O\0011\001\019\001\153\000h\001\141\000.\000h\000Z\001\135\0017\000\251\000.\000:\001g\000\016\000=\001\187\000=\000h\000w\000.\000=\000t\001\027\000\176\000t\000\176\000\168\001\157\001\187\000\168\001\157\000h\000w\000.\000\168\001\157\000\134\000I\0002\000\134\000\250\000\127\0002\000\134\000q\000\250\000\127\0002\000|\000\223\000\127\0002\000|\0002\000z\000\223\000\127\0002\000z\000\223\000\127\000\176\000\137\0002\001\133\000U\000U\000\218\001\185\000\132\001\185\000\167\0002\001\163\000\182\0017\001\175\001I\000\162\001\181\000p\000N\0017\001\007\000\162\001\181\000p\000N\000\252\0017\001\007\000\162\001\181\001\181\001\183\001\163\000\139\001\133\000\148\0017\001\181\000\219\0011\000\148\000\252\0017\001\181\000\219\0011\000\014\000+\0011\000b\001\025\0011\000\226\0017\001\147\0011\000\146\0017\000g\0011\001_\0011\001\127\000\198\001\181\000\238\001\161\000\198\001\181\001Q\001\177\001Q\000\\\001\181\001Q\001\175\001\015\000h\000\179\000.\000h\000\179\000\238\001\141\000.\000h\001\141\000.\000\148\0017\001\165\0011\000\014\0017\000\241\000j\000\238\001\141\0011\000b\0017\000\155\000j\000\238\000\165\0011\000\226\0017\001\147\0011\001_\0011\001\127\001\157\000\134\000}\0002\001\157\001\133\000R\0017\001\169\001+\000\204\001\165\001\183\000p\000N\0017\001\007\000\162\001\165\000p\000N\000\252\0017\001\007\000\162\001\165\000h\001\181\000.\001\173\000\134\000}\0002\001\173\000h\001\181\000\238\001\161\000.\000R\0017\001\171\001)\000\204\001\165\000\205\000C\000\\\001\161\000j\000\238\000C\000\\\001\161\000C\000\\\001\161\000\240\000\020\001\135\0017\000'\001}\000j\000\198\001\165\0011\001=\001\023\000\144\000\242\000$\000\188\000\134\0002\000h\000.\000\192\000\026\000\018\000h\000\236\000.\001\153\001\007\001\007\000\218\000h\000\236\000.\000h\000\236\000.\001\153\001\141\000\198\001\141\001\187\000y\000&\001\187\000\138\001Y\0004\000\250\000\149\001\193\001\141\001\183\000\028\000\208\001\031\000\162\000g\000d\001\135\0017\000g\000\004\000\133\000\022\001\135\0017\000g\000\022\001\135\0017\000g\000\004\000\133\000\022\001\135\0017\000g\000\190\000g\000\022\001\135\0017\000g\000\004\000\133\000\190\000g\000\006\001\135\0017\000g\000\224\000g\000\220\000\184\001\135\0017\000\179\000\198\000g\001\139\000g\000\224\000g\000\220\000\184\001\135\0017\000\179\000\162\000g\000\224\000g\000\220\000[\000p\000Z\001\135\0017\000\255\001\005\000\162\000g\000p\000\196\001\135\0017\001\151\001q\0017\000\162\000g\000p\000N\001\135\0017\001\001\000\162\000g\000p\000N\000\252\001\135\0017\001\001\000\162\000g\000\180\001\135\0017\000\133\000\182\001\135\0017\001Q\001y\000\182\001\135\0017\000h\000\020\000\237\000.\001y\000f\001\135\0017\000g\000\004\000\133\000\024\001\135\0017\000g\000\004\000\133\000\164\001\135\0017\000g\000 \001\137\000\206\001\137\000\164\001\135\0017\000g\000 \001\137\000\b\001\135\0017\000g\000\224\000g\000\220\000\186\001\135\0017\000\179\000\198\000g\001\139\000g\000\224\000g\000\220\001\000\001\135\0017\000[\000\140\001\135\0017\000[\000[\000\139\000u\001\149\000[\000\239\000[\001\137\000\158\001\137\001\137\000\156\001\137\001\137\000\154\001\137\001\137\000\152\001\137\001\137\000\150\001\137\001\137\000F\001\137\001\137\000D\001\137\001\137\000B\001\137\001\137\000`\001\137\001\137\000^\001\137\001\137\000&\001\137\001\137\000H\001\137\001\137\000\198\001\137\001\137\000t\001\137\001\137\000\176\001\137\001\137\000J\001\137\001\137\000\248\001\137\001\137\001\b\001\137\001\137\001\n\001\137\001\137\000\234\001\137\000K\001\137\001\195\001\137\001K\000\162\000g\000n\001C\000\162\000g\001\137\000\236\001\137\000j\000r\001\137\000[\000\218\001U\000r\001\137\000[\000\218\000h\000g\000.\000r\001\137\000[\000\218\000\138\000g\0004\000r\001\137\000[\000\218\000\134\000g\0002\000r\001\137\000[\000\212\000h\000o\000.\000r\001\137\000[\000\218\001\007\000\212\000h\000o\000.\000r\001\137\000[\000\212\000\138\000o\0004\000r\001\137\000[\000\218\001\007\000\212\000\138\000o\0004\000r\001\137\000[\000\212\000\134\000o\0002\000r\001\137\000[\000\218\001\007\000\212\000\134\000o\0002\000r\001\137\001\137\001\183\000H\001\185\000x\001\185\000\167\0002\0008\000\250\001\151\000\198\001\149\0017\001\151\000\198\001\149\0017\000\128\001\185\000\167\0002\000\134\000{\0002\000Q\000A\000\198\000g\000\\\000g\000\238\001\187\000\\\000g\001Q\001y\000h\000\020\000\237\000.\001y\000C\000\205\000C\000\\\001w\000j\000\238\000C\000\\\001w\000C\000\\\001w\000h\000.\000h\000\255\000\238\000\251\000.\000\141\000P\001\145\000\238\001\145\000\\\001\187\000\238\000\135\000\218\001\145\000\\\001\187\000\238\001\187\000\238\000\135\000\218\001\187\000\250\001\151\001q\0017\001\151\001q\0017\000\020\001\135\0017\0009\000j\000\234\000\233\000\143\0011\000\020\001\135\0017\000T\0009\000j\000\234\000\233\000\143\0011\000\020\001\135\0017\0009\000j\000?\000\143\0011\000\020\001\135\0017\000T\0009\000j\000?\000\143\0011\000\018\000j\000O\000\202\000,\000\216\000c\000\202\000v\001\185\000\167\0002\0006\000\243\000j\000\238\000\163\0017\000\243\000j\000\238\000\163\0017\000,\0017\001]\001[\001[\001Y\000j\000j\000\238\001\141\001\015\000[\000\142\000[\000\030\000j\000\030\000h\000j\000A\000.\000<\000j\000L\000[\000<\000h\001W\000\209\000.\000<\000j\000L\000h\001G\000\209\000.\000L\000\169\000\030\000h\001W\000.\000\030\000j\000\142\000Y\000Y\001M\000/\000/\000Q\000/\000A\000\198\000g\000/\000\238\000\135\000\218\001\141\000\198\000g\000/\000\238\000\020\000\237\000\218\001\141\000\198\000g\000\171\000\198\000g\000W\000\238\001\141\000\198\000g\000p\001\135\0017\000\153\001O\0011\001K\001\191\000p\0017\000\153\001O\0011\000p\000H\001\185\0017\000\153\001O\0011\001I\001\191\000\179\000\179\000\238\001\141\000/\000Q\000/\000Y\000\238\001\141\000\198\000g\000\171\000\198\000g\001E\001C\001\004\001E\001\006\0017\000'\001}\000j\001\177\0011\001A\001\006\0017\000'\001}\000j\000\238\001\161\0011\001?\001\006\0017\000'\001}\000j\000\198\001\165\0011\001=\001\006\0017\000\255\001\005\0011\001;\001\006\0017\000\255\000\238\000\251\0011\0019\001\183\0017\001\006\0017\0009\000j\000?\000\143\0011\0015\001\006\0017\0009\000j\000\234\000\233\000\143\0011\0013\000\161\0011\000*\001/\000a\001/\000*\001-\000*\000g\0011\001-\000M\001-\001\167\001+\001\179\001)\000M\001'\000*\001%\000*\000g\0011\001%\000M\001%\000G\001%\001U\000\217\000\211\001U\000\217\000\211\000,\001U\000\217\000\211\000,\000\016\000\221\001U\000\217\000\211\000,\001#\000l\001\135\0017\000\153\001O\0011\001!\001\031\001\191\000\179\000\\\000g\000\179\000\n\000g\000\\\000g\000\179\000\\\000\218\000j\000\238\000\163\0017\000,\0017\001\027\001\187\000,\001\027\000j\000\238\000\163\0017\000,\0017\001\187\000,\000j\000\238\000\163\0017\001\187\000\216\0017\000#\000j\000\238\000\165\0017\000\157\000j\000Q\000\252\0017\000\157\000j\000Q\0017\000\157\000j\000\238\000\165\000\198\000g\000\252\0017\000\157\000j\000\238\000\165\000\198\000g\0017\000\157\000j\000\238\000\020\000\237\000\218\001\141\000\198\000g\000\252\0017\000\157\000j\000\238\000\020\000\237\000\218\001\141\000\198\000g\000j\001\t\000\218\000j\000\018\001\t\000\218\000\018\001g\000h\000\236\000.\0001\001\t\000\218\001g\001\t\000\218\000h\000\236\000.\001\t\000\218\0001\001g\001\t\000\218\001g\000j\001\007\000\218\000j\000\018\001\007\000\218\000\018\000/\001\007\000\218\000/\001\021\001\t\000h\001\t\000.\001\r\000\198\001\001\000\238\000\251\000\198\001\001\001u\001\005\000\238\000\251\001u\001\003\000\"\0017\000O\000\204\000\178\0017\001s\000\\\001\001\000\203\001\001\001\183\001\007\001\001\000\203\001\001\000h\000.\001\133\000\016\000\018\000\016\000Z\001\135\0017\000\018\000\234\001\t\0011\000(\0017\000c\000\204\000\178\0017\001s\000\\\000\251\000Z\000\020\000P\0017\001\001\000h\000\251\000.\000\251\001\183\000\245\000\251\000\\\000\251\000\251\000\004\000\129\001\133\000Z\000\020\001\135\0017\001g\000\213\0011\000Z\000\020\001\135\0017\001g\000\234\000\251\0011\001\017\000X\000X\000\012\000X\000\012\000\012\000X\000\254\001g\000j\000j\000\237\000$\000$\000\235\001\141\000>\001\141\001\143\000>\001\143\001\141\000\198\001\143\001\141\000\198\000>\001\143\000\216\000>\000\216\001\141\000\198\000\216\001\141\000\198\000>\000\216\000\138\001Y\0004\000>\000\138\001Y\0004\001\141\000\198\000\138\001Y\0004\001\141\000\198\000>\000\138\001Y\0004\000N\001\135\0017\001\001\0011\000N\000\252\001\135\0017\001\001\0011\000N\001\135\0017\001\t\0011\000N\000\252\001\135\0017\001\t\0011\000@\000n\001\004\000\212\000h\001c\000.\000\212\000h\001c\000.\000r\000\212\000\134\001c\0002\000\212\000\134\001c\0002\000r\000\212\000\138\001c\0004\000\212\000\138\001c\0004\000r\000\166\000\252\000\158\000\156\000\154\000\152\000\150\000F\000D\000B\000`\000^\000&\000H\000\198\000t\000\176\000J\000\248\001\b\001\n\000\234\001\b\000\250\000,\001\002\000j\000\238\001\141\000\198\001\137\000\198\000\251\000\198\000\179\000\198\000g\000A\000L\000<\000j\000\238\000h\001\001\000\238\000\251\000.\000h\001\001\000.\000h\000\014\0017\001\137\000.\000h\000\014\0017\001\137\000\238\000\251\000.\000h\000\014\0017\001\137\000\238\000\251\000\232\000\251\000.\000h\000\014\0017\001\137\000\232\000\251\000.\001\189\000\202\001\149\000\202\001\141\000\202\000g\000\202\001\t\000\202\001\007\000\202\001\001\000\202\000\251\000\202\000\245\000\202\000\179\000\202\000-\000\202\000\179\000\236\000\179\000\179\001\183\000\173\000\179\001\002\000/\000\177\000\179\000\250\000\179\000\196\001\135\0017\000\179\000\177\000\230\000\179\000\179\000\230\000\179\000\175\000\230\000\179\000\171\000\230\000\179\000Y\001\149\000\179\001\149\000h\000\020\000\237\000.\000Y\000\239\000\179\000\140\001\135\0017\000Y\000\171\000\236\000\179\000\171\001\183\000\173\000\171\001\002\000/\000\175\000\171\000\250\000\179\000j\000\016\000O\000\238\000c\000\238\001\141\000<\000\179\000<\000\179\000\n\000g\001\141\000\135\000\218\001\141\001\193\000\135\000\218\001\193\000\130\001\185\000\167\0002\000\194\001\135\0017\000/\000\238\000\165\000\198\000\235\0011\000>\000>\000\012\000>\000\012\000\012\000>\0000\000i\000[\000\004\000i\001m\001o\000\149\001o\001m\001\129\001o\001\131\000\147\001o\000\147\001\131\001m\001o\000\145\001o\000\143\000\226\001\141\000\198\001\141\001u\000\141\001u\001S\000\139\001S\000\239\000\137\000\239\000:\001g\000\135\000:\001g\001\029\000\250\001\029\000\133\000\250\001\029\001\193\000\131\001\b\001\193\000!\000\129\001\006\000!\000q\000\127\000\250\000q\001\141\000}\000\230\001\141\000;\000{\000\230\000;\001\187\000y\000&\001\187\000w\000\230\001\141\001\141\000\230\001\141\000u\000\230\001\137\001\137\000\230\001\137\000s\000&\001\187\001\187\000&\001\187\000I\001\141\001\137\001\137\000,\001\137\000,\000o\000j\000\215\000j\000\215\000,\000j\000\215\000,\000m\000\179\000\179\000,\000\179\000,\000k\001U\000\207\000\215\001U\000\207\000\215\000,\001U\000\207\000\215\000,\000i\001\137\001\137\000,\001\137\000,\000g\001\137\000,\000H\001\185\000g\000\196\001\135\0017\001\151\001q\0017\0011\001/\001_\0011\001\127\000)\000\159\001i\0015\001k\0013\000\020\001\135\0017\0009\000=\000B\000\157\000\145\0011\000\020\001\135\0017\000T\0009\000=\000B\000\157\000\145\0011\000e\000Z\001\135\0017\000\255\001\003\0011\000Z\001\135\0017\000\255\000\198\001\007\0011\000\253\000Z\001\135\0017\0000\000\255\000\238\000\251\0011\0019\000\249\000\247\000\229\000\160\001\135\0017\000\251\0011\000\240\001\135\0017\000'\001}\000j\000\238\001\161\0011\001?\001\159\001\155\000`\000\144\000`\000\188\000F\000\144\000F\000\188\000\138\001#\0004\000\134\000k\0002\000~\000k\000\246\000~\000\246\000\214\001\137\000\174\000\210\000[\000h\000g\000.\000h\000g\000A\000.\000[\000\218\000h\000g\000.\000[\000\218\000\138\000g\0004\000[\000\218\000\134\000g\0002\000[\000\212\000h\000o\000.\000[\000\218\001\007\000\212\000h\000o\000.\000[\000\212\000\138\000o\0004\000[\000\218\001\007\000\212\000\138\000o\0004\000[\000\212\000\134\000o\0002\000[\000\218\001\007\000\212\000\134\000o\0002\000\244\001\135\0017\000g\000\204\000\244\001\135\0017\000\204\000V\001\135\0017\001\173\000h\000Z\001\135\0017\001\001\000.\000h\000Z\001\135\0017\001\001\000\238\000\251\000.\000R\001\135\0017\001\171\001)\000\204\000-\001\155\001\149\000\239\000@\000[\000\252\000[\000\136\000m\000\172\000\136\000\172\000[\000\218\001U\001\007\000\218\000h\000g\000.\001\007\000\218\000\136\000m\000\172\000[\000\168\000j\000[\000\166\000[\001\133\000\016\001\007\000\218\000h\000.\000\138\000\151\0004\001\007\000\218\000\138\000\151\0004\000~\000o\000\246\000~\000\246\001\007\000\218\000~\000o\000\246\001\007\000\218\000~\000\246\000\134\000o\0002\001\007\000\218\000\134\000o\0002\001\007\000\218\000\134\0002\001\007\000\218\000h\000Z\001\135\0017\001\001\000\238\000\251\000.\000/\000W\000h\000\179\000.\000]\000h\000Z\001\135\0017\000\255\000.\000h\000Z\001\135\0017\000\255\000\238\000\251\000.\000\016\000_\000_\000\216\000_\001\149\000\239\000\168\000=\001\007\000\218\000]\001\007\000\218\000\134\0002\001\007\000\218\000h\000.\001\007\000\218\000h\000\179\000.\000h\000\179\000\238\001\141\000.\001\133\000j\000\018\001\006\001\002\001\000\000\244\000\240\000\226\000\224\000\220\000\208\000\206\000\204\000\196\000\194\000\192\000\186\000\182\000\180\000\178\000\164\000\162\000\160\000\148\000\146\000\140\000p\000f\000b\000Z\000X\000V\000T\000R\000P\000N\000J\000>\0000\000(\000\"\000 \000\028\000\026\000\024\000\020\000\014\000\012\000\n\000\b\000\004\000e\000\196\001\135\0017\001\151\000\198\001\149\0017\0011\000\198\000g\001Q\001{\000h\000\020\000\237\000.\001{\001-\000g\0011\001-\001\031\001K\001_\0011\001\127\000\159\000)\001i\0015\000\020\001\135\0017\0009\000=\000B\000\157\000\147\0011\000\020\001\135\0017\000T\0009\000=\000B\000\157\000\147\0011\000S\000Z\001\135\0017\000\255\001\005\0011\000Z\001\135\0017\0000\000\255\001\005\0011\001;\000\249\000\231\000\240\001\135\0017\000'\001}\000j\001\177\0011\001A\001\159\000\160\001\135\0017\001\001\0011\000`\000^\000\239\000P\000\225\000\131\0017\000\239\0017\000\168\001g\000\168\001g\000$\000\168\001g\000\144\000\168\001g\000-\000\168\001g\001\007\000\168\001g\000\192\000\168\001g\000\026\000g\0011\000*\001'\000*\000G\000*\000\202\001\187\000s\000\238\001\141\000\238\001\141\000\232\001\141\000\232\001\141\000\198\000\233\001\023\0005\0007\000;\000h\000{\000.\000:\001g\000\016\000F\000`\000\252\000F\000\252\000\252\000F\000`\000\252\000\252\000`\000\154\000@\001%\000\202\000g\0011\001%\000\202\000h\000\227\000.\000j\0001\001\011\0017\000%\000j\000\238\001\141\0017\000\243\000j\000\198\000g\000\252\0017\000\243\000j\000\198\000g\0017\000\243\000j\000A\000\198\000g\000\252\0017\000\243\000j\000A\000\198\000g\000\014\001\135\0017\000/\000\238\000\165\0011\000\012\000\012\000X\000\012\000\012\000X\000\012\000>\000\012\000\012\000>\000\020\0009\001U\000\031\001\193\000\143\000\020\0009\001U\000\234\001\193\000Z\001\007\000\198\001\t\000Z\001\007\000\234\001\t\000Z\000\020\000\245\000\198\000\251\000Z\000\020\000\245\000\234\000\251\000\198\000\198\000>"), (16, "\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\b\000\t\000\n\000\011\000\012\000\r\000\014\000\015\000\016\000\017\000\018\000\022\000\026\000\027\000\028\000\031\000%\000'\000(\000)\000+\000/\0002\0004\0006\0009\000>\000A\000E\000J\000N\000P\000T\000Z\000[\000\\\000_\000c\000d\000g\000j\000p\000w\000y\000{\000|\000\129\000\135\000\138\000\141\000\145\000\149\000\151\000\152\000\154\000\158\000\160\000\163\000\165\000\166\000\169\000\174\000\174\000\177\000\177\000\181\000\188\000\195\000\199\000\201\000\202\000\203\000\207\000\208\000\213\000\215\000\221\000\228\000\231\000\232\000\236\000\241\000\246\000\247\000\251\001\000\001\003\001\014\001\015\001\016\001\017\001\018\001\019\001\021\001\023\001\024\001\025\001\026\001\029\001\030\001\031\001$\001'\001(\001+\001,\001/\0012\0013\0014\0015\0017\0018\0019\001<\001B\001F\001L\001R\001Z\001a\001l\001u\001v\001~\001\135\001\142\001\150\001\154\001\159\001\167\001\173\001\179\001\187\001\193\001\200\001\211\001\215\001\219\001\221\001\222\001\224\001\226\001\229\001\232\001\235\001\238\001\241\001\244\001\247\001\250\001\253\002\000\002\003\002\006\002\t\002\012\002\015\002\018\002\021\002\024\002\027\002\030\002 \002\"\002%\002)\002,\002/\0024\002;\002B\002I\002P\002Y\002`\002i\002p\002y\002{\002{\002}\002\129\002\130\002\135\002\139\002\143\002\143\002\146\002\147\002\150\002\152\002\156\002\158\002\163\002\164\002\168\002\173\002\176\002\178\002\183\002\184\002\184\002\186\002\190\002\196\002\198\002\202\002\206\002\209\002\218\002\228\002\236\002\245\002\246\002\247\002\249\002\249\002\251\002\253\003\001\003\002\003\007\003\014\003\015\003\016\003\018\003\019\003\022\003\023\003\024\003\026\003\028\003!\003#\003%\003*\003,\0031\0033\0037\0039\003;\003<\003=\003>\003@\003D\003K\003S\003V\003[\003a\003c\003h\003o\003q\003r\003u\003w\003x\003}\003\128\003\129\003\132\003\132\003\140\003\140\003\149\003\149\003\158\003\158\003\164\003\164\003\171\003\171\003\173\003\173\003\181\003\181\003\190\003\190\003\192\003\192\003\194\003\196\003\196\003\198\003\202\003\204\003\204\003\206\003\206\003\208\003\208\003\210\003\210\003\212\003\216\003\218\003\220\003\223\003\227\003\233\003\238\003\244\003\245\003\247\003\250\003\255\004\002\004\t\004\012\004\018\004\020\004\024\004\025\004\026\004\031\004#\004(\004/\0047\004A\004L\004M\004P\004Q\004T\004U\004X\004Y\004\\\004a\004d\004e\004h\004i\004l\004m\004p\004q\004t\004u\004y\004z\004|\004\128\004\130\004\132\004\134\004\138\004\143\004\144\004\146\004\147\004\149\004\152\004\153\004\154\004\155\004\156\004\163\004\167\004\172\004\177\004\180\004\182\004\183\004\186\004\189\004\190\004\197\004\205\004\206\004\206\004\207\004\207\004\208\004\209\004\211\004\213\004\215\004\216\004\218\004\219\004\221\004\222\004\224\004\225\004\227\004\230\004\234\004\235\004\237\004\240\004\244\004\247\004\251\005\000\005\006\005\011\005\017\005\022\005\028\005\029\005\030\005\031\005#\005(\005,\0051\0055\005:\005;\005<\005=\005>\005?\005@\005A\005B\005C\005D\005E\005F\005G\005H\005I\005J\005K\005L\005M\005N\005O\005P\005Q\005Q\005Q\005R\005R\005S\005S\005U\005U\005W\005W\005Y\005Y\005[\005[\005]\005]\005_\005_\005`\005a\005d\005i\005l\005q\005x\005\129\005\136\005\138\005\140\005\142\005\144\005\146\005\148\005\150\005\152\005\154\005\156\005\158\005\161\005\163\005\164\005\167\005\168\005\171\005\175\005\178\005\181\005\184\005\187\005\188\005\190\005\196\005\198\005\202\005\205\005\207\005\208\005\211\005\212\005\215\005\216\005\217\005\218\005\220\005\222\005\224\005\228\005\229\005\232\005\233\005\236\005\240\005\249\005\249\005\250\005\250\005\251\005\252\005\254\006\000\006\000\006\001\006\002\006\005\006\006\006\007\006\t\006\n\006\011\006\012\006\r\006\015\006\017\006\018\006\019\006\021\006\021\006\026\006\027\006\029\006\030\006 \006!\006#\006%\006(\006)\006+\006.\006/\0062\0063\0066\0067\006:\006;\006>\006?\006B\006C\006F\006I\006L\006O\006R\006U\006X\006Y\006Z\006[\006]\006`\006b\006e\006i\006j\006l\006o\006r\006v\006{\006|\006~\006\129\006\134\006\141\006\142\006\144\006\145\006\146\006\147\006\149\006\151\006\160\006\170\006\171\006\177\006\184\006\185\006\194\006\195\006\196\006\197\006\202\006\212\006\213\006\214\006\216\006\218\006\220\006\222\006\225\006\228\006\231\006\233\006\236\006\238\006\241\006\245\006\250\006\255\007\004\007\t\007\016\007\021\007\028\007!\007(\007-\0071\0075\007;\007C\007I\007J\007K\007L\007M\007O\007Q\007T\007V\007Y\007^\007c\007f\007i\007j\007k\007o\007r\007w\007z\007|\007\129\007\133\007\136\007\141\007\145\007\155\007\156\007\157\007\160\007\161\007\167\007\175\007\176\007\177\007\180\007\181\007\182\007\184\007\187\007\191\007\195\007\200\007\205\007\206\007\207\007\208\007\209\007\210\007\211\007\212\007\213\007\214\007\215\007\216\007\217\007\218\007\219\007\220\007\221\007\222\007\223\007\224\007\225\007\226\007\227\007\228\007\229\007\230\007\231\007\232\007\233\007\234\007\235\007\236\007\237\007\238\007\239\007\240\007\241\007\242\007\243\007\244\007\245\007\246\007\247\007\248\007\249\007\250\007\251\007\252\007\253\007\254\007\255\b\000\b\001\b\002\b\n\b\012\b\014\b\019\b\020\b\023\b\024\b\025\b\027\b\028\b\029\b\030\b \b)\b3\b4\b:\bB\bC\bD\bM\bN\bS\bT\bU\bZ\b\\\b^\ba\bd\bg\bj\bm\bp\bs\bu\bw\bx\by\bz\b|\b\128\b\130\b\130\b\132\b\133\b\135\b\135\b\136\b\139\b\141\b\142\b\142\b\143\b\144\b\145\b\147\b\149\b\151\b\153\b\154\b\155\b\157\b\161\b\164\b\165\b\166\b\167\b\172\b\177\b\183\b\189\b\196\b\203\b\203\b\204\b\205\b\207\b\209\b\210\b\212\b\214\b\220\b\225\b\229\b\233\b\238\b\243\b\244\b\246")) + ((16, "\001g\001c\000\203\000\201\000\199\000\197\000\195\000\193\000\191\000\189\000\187\000\185\000\183\000E\0003\000B\000@\001y\001\207\000\246\0006\001i\000\250\0019\001Q\0013\001\025\001\165\001\151\000=\001\201\000=\000b\000w\000*\000=\000\160\001\169\001\201\000\160\001\169\000b\000w\000*\000\160\001\169\001\015\000\206\001\149\0006\001i\000\014\000U\000U\000\206\001\199\000\169\000|\001\199\001\197\000.\001\175\000\174\0019\001\187\001K\000\154\001\193\000h\000J\0019\001\r\000\154\001\193\000h\000J\000\240\0019\001\r\000\154\001\193\001\193\001\195\001\175\000\139\001\143\000\140\0019\001\193\000\223\0013\000\140\000\240\0019\001\193\000\223\0013\000\012\000+\0013\000^\001\031\0013\000\214\0019\001\159\0013\000\138\0019\000g\0013\001a\0013\001\135\000\186\001\193\000\226\001\173\000\186\001\193\001S\001\189\001S\000X\001\193\001S\001\187\001\021\000b\000\181\000*\000b\000\181\000\226\001\153\000*\000b\001\153\000*\000\140\0019\001\177\0013\000\012\0019\000\247\000d\000\226\001\153\0013\000^\0019\000\157\000d\000\226\000\167\0013\000\214\0019\001\159\0013\001a\0013\001\135\001\169\000~\000}\000.\001\169\001\143\000N\0019\001\181\001-\000\192\001\177\001\195\000h\000J\0019\001\r\000\154\001\177\000h\000J\000\240\0019\001\r\000\154\001\177\000b\001\193\000*\001\185\000~\000}\000.\001\185\000b\001\193\000\226\001\173\000*\000N\0019\001\183\001+\000\192\001\177\000\207\000C\000X\001\173\000d\000\226\000C\000X\001\173\000C\000X\001\173\000\228\000\018\001\145\0019\000'\001\133\000d\000\186\001\177\0013\001?\001\029\000\136\000\230\000 \000\178\000~\000.\000b\000*\000\180\000\022\000\016\000b\000\224\000*\001\165\001\r\001\r\000\206\000b\000\224\000*\000b\000\224\000*\001\165\001\153\000\186\001\153\001\201\000y\000\"\001\201\000\130\001[\0000\000\238\000\151\001\207\001\153\001\195\000\237\001\137\001\149\000b\001\153\000*\000b\000V\001\145\0019\001\001\000*\000~\000I\000.\000~\000\238\000\127\000.\000~\000q\000\238\000\127\000.\000t\000\227\000\127\000.\000t\000.\000r\000\227\000\127\000.\000r\000\227\000\127\000\168\000\137\000.\000\024\000\196\000D\001\199\000p\001\199\000\169\000.\0004\000\238\001\163\000\186\001\161\0019\001\163\000\186\001\161\0019\001\143\000x\001\199\001\197\000.\000~\000{\000.\000\172\001\145\0019\000\133\001{\000[\000h\000V\001\145\0019\001\005\001\011\000\154\000g\000h\000\184\001\145\0019\001\163\001s\0019\000\154\000g\000h\000J\001\145\0019\001\007\000\154\000g\000h\000J\000\240\001\145\0019\001\007\000\154\000g\000\174\001\145\0019\001}\000\221\000X\001\131\000`\001\145\0019\000g\000\004\000\133\000\020\001\145\0019\000g\000\004\000\133\000\156\001\145\0019\000g\000\028\001\129\000\194\001\129\000\156\001\145\0019\000g\000\028\001\129\000\194\000\172\001\145\0019\000\133\000\156\001\145\0019\000g\000\028\000\172\001\145\0019\000\133\000\194\001\129\000\156\001\145\0019\000g\000\028\000\172\001\145\0019\000\133\000\194\000\172\001\145\0019\000\133\000\156\001\145\0019\000g\000\028\001\129\000\156\001\145\0019\000g\000\028\000\172\001\145\0019\000\133\000\006\001\145\0019\000g\000\212\000g\000\208\000\176\001\145\0019\000\181\000\186\000g\001\147\000g\000\212\000g\000\208\000\244\001\145\0019\000[\000\132\001\145\0019\000[\000[\000\139\000u\001\161\000[\000\245\000[\001\129\000\150\001\129\001\129\000\150\000\172\001\145\0019\000\133\001\129\000\148\001\129\001\129\000\148\000\172\001\145\0019\000\133\001\129\000\146\001\129\001\129\000\146\000\172\001\145\0019\000\133\001\129\000\144\001\129\001\129\000\144\000\172\001\145\0019\000\133\001\129\000\142\001\129\001\129\000\142\000\172\001\145\0019\000\133\001\129\000B\001\129\001\129\000B\000\172\001\145\0019\000\133\001\129\000@\001\129\001\129\000@\000\172\001\145\0019\000\133\001\129\000>\001\129\001\129\000>\000\172\001\145\0019\000\133\001\129\000\\\001\129\001\129\000\\\000\172\001\145\0019\000\133\001\129\000Z\001\129\001\129\000Z\000\172\001\145\0019\000\133\001\129\000\"\001\129\001\129\000\"\000\172\001\145\0019\000\133\001\129\000D\001\129\001\129\000D\000\172\001\145\0019\000\133\001\129\000\186\001\129\001\129\000\186\000\172\001\145\0019\000\133\001\129\000l\001\129\001\129\000l\000\172\001\145\0019\000\133\001\129\000\168\001\129\001\129\000\168\000\172\001\145\0019\000\133\001\129\000F\001\129\001\129\000F\000\172\001\145\0019\000\133\001\129\000\236\001\129\001\129\000\236\000\172\001\145\0019\000\133\001\129\000\252\001\129\001\129\000\252\000\172\001\145\0019\000\133\001\129\000\254\001\129\001\129\000\254\000\172\001\145\0019\000\133\001\129\000\222\001\129\001\129\000\222\000\172\001\145\0019\000\133\000K\001\129\000K\000\172\001\145\0019\000\133\001\209\001\129\001\209\000\172\001\145\0019\000\133\001M\000\154\000g\000f\001E\000\154\000g\001\129\000\224\001\129\001\129\000\224\000\172\001\145\0019\000\133\000d\000j\001\129\000d\000j\000\172\001\145\0019\000\133\000[\000\206\001W\000j\001\129\000[\000\206\001W\000j\000\172\001\145\0019\000\133\000[\000\206\000b\000g\000*\000j\001\129\000[\000\206\000b\000g\000*\000j\000\172\001\145\0019\000\133\000[\000\206\000\130\000g\0000\000j\001\129\000[\000\206\000\130\000g\0000\000j\000\172\001\145\0019\000\133\000[\000\206\000~\000g\000.\000j\001\129\000[\000\206\000~\000g\000.\000j\000\172\001\145\0019\000\133\000[\000\200\000b\000o\000*\000j\001\129\000[\000\200\000b\000o\000*\000j\000\172\001\145\0019\000\133\000[\000\206\001\r\000\200\000b\000o\000*\000j\001\129\000[\000\206\001\r\000\200\000b\000o\000*\000j\000\172\001\145\0019\000\133\000[\000\200\000\130\000o\0000\000j\001\129\000[\000\200\000\130\000o\0000\000j\000\172\001\145\0019\000\133\000[\000\206\001\r\000\200\000\130\000o\0000\000j\001\129\000[\000\206\001\r\000\200\000\130\000o\0000\000j\000\172\001\145\0019\000\133\000[\000\200\000~\000o\000.\000j\001\129\000[\000\200\000~\000o\000.\000j\000\172\001\145\0019\000\133\000[\000\206\001\r\000\200\000~\000o\000.\000j\001\129\000[\000\206\001\r\000\200\000~\000o\000.\000j\000\172\001\145\0019\000\133\001\129\001\195\000b\000\018\000\243\000*\001S\000\143\001\129\001\129\000(\001\129\000(\000g\001\129\000(\000D\001\199\000g\000C\000\207\000C\000X\001y\000d\000\226\000C\000X\001y\000C\000X\001y\000b\000*\000b\001\005\000\226\001\001\000*\000\141\000L\001\157\000\226\001\157\000X\001\201\000\226\000\135\000\206\001\157\000X\001\201\000\226\001\201\000\226\000\135\000\206\001\201\000\238\001\163\001s\0019\001\163\001s\0019\000\018\001\145\0019\0009\000d\000\222\000\239\000\145\0013\000\018\001\145\0019\000P\0009\000d\000\222\000\239\000\145\0013\000\018\001\145\0019\0009\000d\000?\000\145\0013\000\018\001\145\0019\000P\0009\000d\000?\000\145\0013\000\016\000d\000O\000\190\000(\000\204\000c\000\190\000n\001\199\000\169\000.\0002\000\249\000d\000\226\000\165\0019\000\249\000d\000\226\000\165\0019\000(\0019\001_\001]\001]\001[\000d\000d\000\226\001\153\001\021\000[\000\134\000[\000\026\000d\000\026\000b\000d\000A\000*\0008\000d\000H\000[\0008\000b\001Y\000\211\000*\0008\000d\000H\000b\001I\000\211\000*\000H\000\171\000\026\000b\001Y\000*\000\026\000d\000\134\000Y\000Y\001O\000/\000/\000Q\000/\000A\000\186\000g\000/\000\226\000\135\000\206\001\153\000\186\000g\000/\000\226\000\018\000\243\000\206\001\153\000\186\000g\000\173\000\186\000g\000W\000\226\001\153\000\186\000g\000h\001\145\0019\000\155\001Q\0013\001M\001\205\000h\0019\000\155\001Q\0013\000h\000D\001\199\0019\000\155\001Q\0013\001K\001\205\000\181\000\181\000\226\001\153\000/\000Q\000/\000Y\000\226\001\153\000\186\000g\000\173\000\186\000g\001G\001E\000\248\001G\000\250\0019\000'\001\133\000d\001\189\0013\001C\000\250\0019\000'\001\133\000d\000\226\001\173\0013\001A\000\250\0019\000'\001\133\000d\000\186\001\177\0013\001?\000\250\0019\001\005\001\011\0013\001=\000\250\0019\001\005\000\226\001\001\0013\001;\001\195\0019\000\250\0019\0009\000d\000?\000\145\0013\0017\000\250\0019\0009\000d\000\222\000\239\000\145\0013\0015\000\163\0013\000&\0011\000a\0011\000&\001/\000&\000g\0013\001/\000M\001/\001\179\001-\001\191\001+\000M\001)\000&\001'\000&\000g\0013\001'\000M\001'\000G\001'\001W\000\219\000\213\001W\000\219\000\213\000(\001W\000\219\000\213\000(\000\014\000\225\001W\000\219\000\213\000(\001%\000\181\000X\000g\000\181\000\b\000g\000X\000g\000\181\000X\000\206\000d\000\226\000\165\0019\000(\0019\001!\001\201\000(\001!\000d\000\226\000\165\0019\000(\0019\001\201\000(\000d\000\226\000\165\0019\001\201\000\204\0019\000#\000d\000\226\000\167\0019\000\159\000d\000Q\000\240\0019\000\159\000d\000Q\0019\000\159\000d\000\226\000\167\000\186\000g\000\240\0019\000\159\000d\000\226\000\167\000\186\000g\0019\000\159\000d\000\226\000\018\000\243\000\206\001\153\000\186\000g\000\240\0019\000\159\000d\000\226\000\018\000\243\000\206\001\153\000\186\000g\000d\001\015\000\206\000d\000\016\001\015\000\206\000\016\001i\000b\000\224\000*\0001\001\015\000\206\001i\001\015\000\206\000b\000\224\000*\001\015\000\206\0001\001i\001\015\000\206\001i\000d\001\r\000\206\000d\000\016\001\r\000\206\000\016\000/\001\r\000\206\000/\001\027\001\015\000b\001\015\000*\001\019\000\186\001\007\000\226\001\001\000\186\001\007\001w\001\011\000\226\001\001\001w\001\t\000\030\0019\000O\000\192\000\170\0019\001u\000X\001\007\000\205\001\007\001\195\001\r\001\007\000\205\001\007\000b\000*\001\143\000\014\000\016\000\014\000V\001\145\0019\000\016\000\222\001\015\0013\000$\0019\000c\000\192\000\170\0019\001u\000X\001\001\000V\000\018\000L\0019\001\007\000b\001\001\000*\001\001\001\195\000\251\000b\000*\000X\001\001\001\001\000X\001\001\001\001\000\004\000\129\001\143\000V\000\018\001\145\0019\001i\000\215\0013\000V\000\018\001\145\0019\001i\000\222\001\001\0013\001\023\000T\000T\000\n\000T\000\n\000\n\000T\000\242\001i\000d\000d\000\243\000 \000 \000\241\001\153\000:\001\153\001\155\000:\001\155\001\153\000\186\001\155\001\153\000\186\000:\001\155\000\204\000:\000\204\001\153\000\186\000\204\001\153\000\186\000:\000\204\000\130\001[\0000\000:\000\130\001[\0000\001\153\000\186\000\130\001[\0000\001\153\000\186\000:\000\130\001[\0000\000l\001!\000\168\000l\000\168\000J\001\145\0019\001\007\0013\000J\000\240\001\145\0019\001\007\0013\000J\001\145\0019\001\015\0013\000J\000\240\001\145\0019\001\015\0013\000<\000f\000\248\000\200\000b\001e\000*\000\200\000b\001e\000*\000j\000\200\000~\001e\000.\000\200\000~\001e\000.\000j\000\200\000\130\001e\0000\000\200\000\130\001e\0000\000j\000\158\000\240\000\150\000\148\000\146\000\144\000\142\000B\000@\000>\000\\\000Z\000\"\000D\000\186\000l\000\168\000F\000\236\000\252\000\254\000\222\000\252\000\238\000(\000\246\000d\000\226\001\201\000\226\001\153\000\186\001\129\000\186\000\172\001\145\0019\000\133\000\186\001\001\000\186\000\181\000\186\000g\000A\000H\0008\000d\000\226\000b\001\007\000\226\001\001\000*\000b\001\007\000*\000b\000\012\0019\001\129\000*\000b\000\012\0019\000\172\001\145\0019\000\133\000*\000b\000\012\0019\001\129\000\226\001\001\000*\000b\000\012\0019\000\172\001\145\0019\000\133\000\226\001\001\000*\000b\000\012\0019\001\129\000\226\001\001\000\220\001\001\000*\000b\000\012\0019\000\172\001\145\0019\000\133\000\226\001\001\000\220\001\001\000*\000b\000\012\0019\001\129\000\220\001\001\000*\000b\000\012\0019\000\172\001\145\0019\000\133\000\220\001\001\000*\001\203\000\190\001\161\000\190\001\153\000\190\000g\000\190\001\015\000\190\001\r\000\190\001\007\000\190\001\001\000\190\000\251\000\190\000\181\000\190\000-\000\190\000\181\000\224\000\181\000\181\001\195\000\175\000\181\000\246\000/\000\179\000\181\000\238\000\181\000\184\001\145\0019\000\181\000\179\000\218\000\181\000\181\000\218\000\181\000\177\000\218\000\181\000\173\000\218\000\181\000Y\001\161\000\181\001\161\000b\000\018\000\243\000*\000Y\000\245\000\181\000\132\001\145\0019\000Y\000\173\000\224\000\181\000\173\001\195\000\175\000\173\000\246\000/\000\177\000\173\000\238\000\181\000d\000\014\000O\000\226\000c\000\226\001\153\0008\000\181\0008\000\181\000\b\000g\001\153\000\135\000\206\001\153\001\207\000\135\000\206\001\207\000z\001\199\001\197\000.\000\182\001\145\0019\000/\000\226\000\167\000\186\000\241\0013\000:\000:\000\n\000:\000\n\000\n\000:\000,\000i\000[\000\004\000i\001o\001q\000\151\001q\001o\001\139\001q\001\141\000\149\001q\000\149\001\141\001o\001q\000\147\001q\000\145\000\214\001\153\000\186\001\153\001\127\000\143\001\127\001w\000\141\001w\001U\000\139\001U\000\245\000\137\000\245\0006\001i\000\135\0006\001i\001#\000\238\001#\000\133\000\238\001#\001\207\000\131\000\252\001\207\000!\000\129\000\250\000!\000q\000\127\000\238\000q\001\153\000}\000\218\001\153\000;\000{\000\218\000;\001\201\000y\000\"\001\201\000w\000\218\001\153\001\153\000\218\001\153\000u\000\218\001\129\000u\000\218\000\172\001\145\0019\000\133\001\129\000\218\001\129\001\129\000\218\000\172\001\145\0019\000\133\000\172\001\145\0019\000\133\000\218\001\129\000\172\001\145\0019\000\133\000\218\000\172\001\145\0019\000\133\000s\000\"\001\201\001\201\000\"\001\201\000I\001\153\001\129\001\129\000(\000\172\001\145\0019\000\133\000\172\001\145\0019\000\133\000(\001\129\000(\000o\000\172\001\145\0019\000\133\000(\000o\000d\000\217\000d\000\217\000(\000d\000\217\000(\000m\000\181\000\181\000(\000\181\000(\000k\001W\000\209\000\217\001W\000\209\000\217\000(\001W\000\209\000\217\000(\000i\001{\000\172\001\145\0019\000\133\000\184\001\145\0019\001\163\001s\0019\0013\0011\001a\0013\001\135\000)\000\161\001k\0017\001m\0015\000\018\001\145\0019\0009\000=\000>\000\159\000\147\0013\000\018\001\145\0019\000P\0009\000=\000>\000\159\000\147\0013\000e\000V\001\145\0019\001\005\001\t\0013\000V\001\145\0019\001\005\000\186\001\r\0013\001\003\000V\001\145\0019\000,\001\005\000\226\001\001\0013\001;\000\255\000\253\000\233\000\152\001\145\0019\001\001\0013\000\228\001\145\0019\000'\001\133\000d\000\226\001\173\0013\001A\001\171\001\167\000\\\000\136\000\\\000\178\000B\000\136\000B\000\178\000\130\001%\0000\000~\000k\000.\000v\000k\000\234\000v\000\234\000\202\001\129\000\166\000\202\000\172\001\145\0019\000\133\000\166\000\198\000[\000b\000g\000*\000b\000g\000A\000*\000[\000\206\000b\000g\000*\000[\000\206\000\130\000g\0000\000[\000\206\000~\000g\000.\000[\000\200\000b\000o\000*\000[\000\206\001\r\000\200\000b\000o\000*\000[\000\200\000\130\000o\0000\000[\000\206\001\r\000\200\000\130\000o\0000\000[\000\200\000~\000o\000.\000[\000\206\001\r\000\200\000~\000o\000.\000\232\001\145\0019\000g\000\192\000\232\001\145\0019\000\192\000R\001\145\0019\001\185\000b\000V\001\145\0019\001\007\000*\000b\000V\001\145\0019\001\007\000\226\001\001\000*\000N\001\145\0019\001\183\001+\000\192\000-\001\167\001\161\000\245\000<\000[\000\240\000[\000\128\000m\000\164\000\128\000\164\000[\000\206\001W\001\r\000\206\000b\000g\000*\001\r\000\206\000\128\000m\000\164\000[\000\160\000d\000[\000\158\000[\001\143\000\014\001\r\000\206\000b\000*\000\130\000\153\0000\001\r\000\206\000\130\000\153\0000\000v\000o\000\234\000v\000\234\001\r\000\206\000v\000o\000\234\001\r\000\206\000v\000\234\000~\000o\000.\001\r\000\206\000~\000o\000.\001\r\000\206\000~\000.\001\r\000\206\000b\000V\001\145\0019\001\007\000\226\001\001\000*\000/\000W\000b\000\181\000*\000]\000b\000V\001\145\0019\001\005\000*\000b\000V\001\145\0019\001\005\000\226\001\001\000*\000\014\000_\000_\000\204\000_\001\161\000\245\000\160\000=\001\r\000\206\000]\001\r\000\206\000~\000.\001\r\000\206\000b\000*\001\r\000\206\000b\000\181\000*\000b\000\181\000\226\001\153\000*\001\143\000d\000\016\000\250\000\246\000\244\000\232\000\228\000\214\000\212\000\208\000\196\000\194\000\192\000\184\000\182\000\180\000\176\000\174\000\172\000\170\000\156\000\154\000\152\000\140\000\138\000\132\000h\000`\000^\000V\000T\000R\000P\000N\000L\000J\000F\000:\000,\000$\000\030\000\028\000\024\000\022\000\020\000\018\000\012\000\n\000\b\000\006\000\004\000e\000\184\001\145\0019\001\163\000\186\001\161\0019\0013\000\186\000g\001}\000\209\000\186\001\131\001/\000g\0013\001/\001M\001a\0013\001\135\000\161\000)\001k\0017\000\018\001\145\0019\0009\000=\000>\000\159\000\149\0013\000\018\001\145\0019\000P\0009\000=\000>\000\159\000\149\0013\000S\000V\001\145\0019\001\005\001\011\0013\000V\001\145\0019\000,\001\005\001\011\0013\001=\000\255\000\235\000\228\001\145\0019\000'\001\133\000d\001\189\0013\001C\001\171\000\152\001\145\0019\001\007\0013\000\\\000Z\000\245\000L\000\229\000\131\0019\000\245\0019\000\160\001i\000\160\001i\000 \000\160\001i\000\136\000\160\001i\000-\000\160\001i\001\r\000\160\001i\000\180\000\160\001i\000\022\000g\0013\000&\001)\000&\000G\000&\000\190\001\201\000s\000\226\001\153\000\226\001\153\000\220\001\153\000\220\001\153\000\186\000\239\001\029\0005\0007\000;\000b\000{\000*\0006\001i\000\014\000B\000\\\000\240\000B\000\240\000\240\000B\000\\\000\240\000\240\000\\\000\146\000<\001'\000\190\000g\0013\001'\000\190\000b\000\231\000*\000d\0001\001\017\0019\000%\000d\000\226\001\153\0019\000\249\000d\000\186\000g\000\240\0019\000\249\000d\000\186\000g\0019\000\249\000d\000A\000\186\000g\000\240\0019\000\249\000d\000A\000\186\000g\000\012\001\145\0019\000/\000\226\000\167\0013\000\n\000\n\000T\000\n\000\n\000T\000\n\000:\000\n\000\n\000:\000\018\0009\001W\000\031\001\207\000\145\000\018\0009\001W\000\222\001\207\000V\001\r\000\186\001\015\000V\001\r\000\222\001\015\000V\000\018\000\251\000\186\001\001\000V\000\018\000\251\000\222\001\001\000\186\000\186\000:"), (16, "\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\b\000\t\000\n\000\011\000\012\000\r\000\014\000\015\000\016\000\017\000\018\000\022\000\026\000\027\000\028\000\029\000\030\000 \000$\000&\000)\000.\0001\0003\0004\0005\0008\0009\000=\000>\000A\000D\000J\000Q\000S\000U\000V\000[\000a\000d\000g\000k\000o\000q\000r\000t\000x\000z\000}\000\127\000\128\000\131\000\136\000\136\000\139\000\139\000\143\000\150\000\157\000\161\000\163\000\164\000\165\000\169\000\170\000\175\000\177\000\183\000\190\000\193\000\194\000\198\000\203\000\208\000\209\000\213\000\218\000\221\000\232\000\233\000\234\000\235\000\236\000\237\000\239\000\241\000\242\000\243\000\244\000\247\000\248\000\249\000\254\001\001\001\002\001\005\001\006\001\t\001\012\001\r\001\014\001\015\001\017\001\018\001\019\001\020\001\023\001\029\001 \001$\001)\001-\001/\0013\0019\001:\001;\001;\001=\001A\001B\001G\001K\001L\001P\001P\001S\001W\001X\001Y\001a\001j\001q\001y\001\128\001\134\001\140\001\148\001\159\001\170\001\184\001\190\001\199\001\206\001\217\001\221\001\225\001\227\001\228\001\230\001\232\001\235\001\241\001\244\001\250\001\253\002\003\002\006\002\012\002\015\002\021\002\024\002\030\002!\002'\002*\0020\0023\0029\002<\002B\002E\002K\002N\002T\002W\002]\002`\002f\002i\002o\002r\002x\002{\002\129\002\132\002\138\002\141\002\147\002\150\002\156\002\158\002\163\002\165\002\170\002\173\002\177\002\180\002\186\002\189\002\195\002\200\002\208\002\215\002\225\002\232\002\242\002\249\003\003\003\n\003\020\003\029\003)\0030\003:\003C\003O\003V\003`\003i\003u\003w\003{\003|\003}\003~\003\128\003\131\003\136\003\137\003\141\003\146\003\149\003\151\003\156\003\157\003\157\003\159\003\163\003\169\003\171\003\175\003\179\003\182\003\191\003\201\003\209\003\218\003\219\003\220\003\222\003\222\003\224\003\226\003\230\003\231\003\236\003\243\003\244\003\245\003\247\003\248\003\251\003\252\003\253\003\255\004\001\004\006\004\b\004\n\004\015\004\017\004\022\004\024\004\028\004\030\004 \004!\004\"\004#\004%\004)\0040\0048\004;\004@\004F\004H\004M\004T\004V\004W\004Z\004\\\004]\004b\004e\004f\004i\004i\004q\004q\004z\004z\004\131\004\131\004\137\004\137\004\144\004\144\004\146\004\146\004\154\004\154\004\163\004\163\004\165\004\165\004\167\004\169\004\169\004\171\004\175\004\177\004\177\004\179\004\179\004\181\004\181\004\183\004\183\004\185\004\189\004\191\004\193\004\196\004\200\004\206\004\211\004\214\004\219\004\222\004\229\004\232\004\238\004\240\004\244\004\245\004\246\004\251\004\255\005\004\005\011\005\019\005\029\005(\005)\005,\005-\0050\0051\0054\0055\0058\005=\005@\005A\005D\005E\005H\005I\005L\005M\005P\005Q\005U\005V\005X\005\\\005^\005`\005b\005f\005k\005l\005n\005o\005q\005t\005u\005v\005w\005x\005\127\005\131\005\136\005\141\005\144\005\146\005\147\005\151\005\154\005\157\005\158\005\165\005\173\005\174\005\174\005\175\005\175\005\176\005\177\005\179\005\181\005\183\005\184\005\186\005\187\005\189\005\190\005\192\005\193\005\195\005\198\005\202\005\203\005\205\005\208\005\212\005\215\005\219\005\224\005\230\005\233\005\235\005\240\005\246\005\251\006\001\006\002\006\003\006\004\006\b\006\r\006\017\006\022\006\026\006\031\006 \006!\006\"\006#\006$\006%\006&\006'\006(\006)\006*\006+\006,\006-\006.\006/\0060\0061\0062\0063\0064\0065\0066\0066\0066\0067\0067\0068\0068\006:\006:\006<\006<\006>\006>\006@\006E\006E\006G\006G\006I\006I\006K\006K\006L\006M\006P\006U\006X\006]\006e\006l\006v\006\127\006\139\006\146\006\156\006\158\006\160\006\162\006\164\006\166\006\168\006\170\006\172\006\174\006\176\006\178\006\181\006\183\006\184\006\187\006\188\006\191\006\195\006\198\006\201\006\204\006\207\006\208\006\210\006\216\006\218\006\222\006\225\006\227\006\228\006\231\006\232\006\235\006\236\006\237\006\238\006\240\006\242\006\244\006\248\006\249\006\252\006\253\007\000\007\004\007\r\007\r\007\014\007\014\007\015\007\016\007\018\007\020\007\020\007\021\007\022\007\025\007\026\007\027\007\029\007\030\007\031\007 \007!\007#\007%\007&\007'\007)\007)\007.\007/\0071\0072\0074\0075\0077\0078\007:\007<\007?\007@\007B\007E\007F\007I\007J\007M\007N\007Q\007R\007U\007V\007Y\007Z\007]\007`\007c\007f\007l\007o\007u\007{\007\132\007\135\007\138\007\139\007\140\007\141\007\143\007\147\007\152\007\155\007\161\007\163\007\166\007\170\007\171\007\173\007\176\007\179\007\183\007\188\007\189\007\193\007\200\007\201\007\203\007\204\007\205\007\206\007\208\007\210\007\219\007\229\007\230\007\236\007\243\007\244\007\253\007\254\007\255\b\000\b\005\b\015\b\016\b\017\b\019\b\021\b\023\b\025\b\028\b\031\b\"\b$\b'\b-\b/\b2\b6\b;\b@\bE\bJ\bQ\bV\b]\bb\bi\bn\br\bv\b|\b\132\b\138\b\139\b\140\b\141\b\142\b\144\b\146\b\149\b\151\b\154\b\159\b\164\b\167\b\170\b\171\b\172\b\176\b\179\b\184\b\187\b\189\b\194\b\198\b\201\b\206\b\210\b\220\b\221\b\222\b\225\b\226\b\232\b\240\b\241\b\242\b\245\b\246\b\247\b\249\b\252\t\000\t\004\t\t\t\014\t\015\t\016\t\017\t\018\t\019\t\020\t\021\t\022\t\023\t\024\t\025\t\026\t\027\t\028\t\029\t\030\t\031\t \t!\t\"\t#\t$\t%\t&\t'\t(\t)\t*\t+\t,\t-\t.\t/\t0\t1\t2\t3\t4\t5\t6\t7\t8\t9\t:\t;\t<\t=\t>\t?\t@\tA\tB\tC\tK\tM\tQ\tR\tU\tV\tX\tY\tZ\t[\t]\tf\tp\tq\tw\t\127\t\128\t\129\t\138\t\139\t\144\t\145\t\146\t\151\t\153\t\155\t\158\t\161\t\164\t\167\t\170\t\173\t\176\t\178\t\180\t\181\t\182\t\183\t\185\t\189\t\191\t\191\t\193\t\194\t\196\t\196\t\197\t\200\t\202\t\203\t\203\t\204\t\205\t\206\t\208\t\210\t\212\t\214\t\215\t\216\t\218\t\222\t\225\t\226\t\227\t\228\t\233\t\238\t\244\t\250\n\001\n\b\n\b\n\t\n\n\n\012\n\014\n\015\n\017\n\019\n\025\n\030\n\"\n&\n+\n0\n1\n3")) and lr0_core = - (16, "\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\b\000\t\000\n\000\011\000\012\000\r\000\014\000\015\000\016\000\017\000\018\000\019\000\020\000\021\000\022\000\023\000\024\000\025\000\026\000\027\000\028\000\029\000\030\000\031\000 \000!\000\"\000#\000$\000%\000&\000'\000(\000)\000*\000+\000,\000-\000.\000/\0000\0001\0002\0003\0004\0005\0006\0007\0008\0009\000:\000;\000<\000=\000>\000?\000@\000A\000B\000C\000D\000E\000F\000G\000H\000I\000J\000K\000L\000M\000N\000O\000P\000Q\000R\000S\000T\000U\000V\000W\000X\000Y\000Z\000[\000\\\000]\000^\000_\000`\000a\000b\000c\000d\000e\000f\000g\000h\000i\000j\000k\000l\000m\000n\000o\000p\000q\000r\000s\000t\000u\000v\000w\000x\000y\000z\000{\000|\000}\000~\000\127\000\128\000\129\000\130\000\131\000\132\000\133\000\134\000\135\000\136\000\137\000\138\000\139\000\140\000\141\000\142\000\143\000\144\000\145\000\146\000\147\000\148\000\149\000\150\000\151\000\152\000\153\000\154\000\155\000\156\000\157\000\158\000\159\000\160\000\161\000\162\000\163\000\164\000\165\000\166\000\167\000\168\000\169\000\170\000\171\000\172\000\173\000\174\000\175\000\176\000\177\000\178\000\179\000\180\000\181\000\182\000\183\000\184\000\185\000\186\000\187\000\188\000\189\000\190\000\191\000\192\000\193\000\194\000\195\000\196\000\197\000\198\000\199\000\200\000\201\000\202\000\203\000\204\000\205\000\206\000\207\000\208\000\209\000\210\000\211\000\212\000\213\000\214\000\215\000\216\000\217\000\218\000\219\000\220\000\221\000\222\000\223\000\224\000\225\000\226\000\227\000\228\000\229\000\230\000\231\000\232\000\233\000\234\000\235\000\236\000\237\000\238\000\239\000\240\000\241\000\242\000\243\000\244\000\245\000\246\000\247\000\248\000\249\000\250\000\251\000\252\000\253\000\254\000\255\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\b\001\t\001\n\001\011\001\012\001\r\001\014\001\015\001\016\001\017\001\018\001\019\001\020\001\021\001\022\001\023\001\024\001\025\001\026\001\027\001\028\001\029\001\030\001\031\001 \001!\001\"\001#\001$\001%\001&\001'\001(\001)\001*\001+\001,\001-\001.\001/\0010\0011\0012\0013\0014\0015\0016\0017\0018\0019\001:\001;\001<\001=\001>\001?\001@\001A\001B\001C\001D\001E\001F\001G\001H\001I\001J\001K\001L\001M\001N\001O\001P\001Q\001R\001S\001T\001U\001V\001W\001X\001Y\001Z\001[\001\\\001]\001^\001_\001`\001a\001b\001c\001d\001e\001f\001g\001h\001i\001j\001k\001l\001m\001n\001o\001p\001q\001r\001s\001t\001u\001v\001y\001z\001\127\001\128\001\129\001\130\001\131\001\132\001\133\001\134\001\135\001\136\001\137\001\138\001\139\001\140\001\141\001\142\001\143\001\144\001\145\001w\001x\001\146\001\147\001\148\001{\001|\001}\001~\001\149\001\150\001\151\001\152\001\153\001\154\001\155\001\156\001\157\001\158\001\159\001\160\001\161\001\162\001\163\001\164\001\165\001\166\001\167\001\168\001\169\001\170\001\171\001\172\001\173\001\174\001\175\001\176\001\177\001\178\001\179\001\180\001\181\001\182\001\183\001\184\001\185\001\186\001\187\001\188\001\189\001\190\001\191\001\192\001\193\001\194\001\195\001\196\001\197\001\198\001\199\001\200\001\201\001\202\001\203\001\204\001\205\001\206\001\207\001\208\001\209\001\210\001\211\001\212\001\213\001\214\001\215\001\216\001\217\001\218\001\219\001\220\001\221\001\222\001\223\001\224\001\225\001\226\001\227\001\228\001\229\001\230\001\231\001\232\001\233\001\234\001\235\001\236\001\237\001\238\001\239\001\240\001\241\001\242\001\243\001\244\001\245\001\246\001\249\001\250\001\251\001\252\001\253\001\254\001\255\002\000\002\001\002\002\001\247\001\248\002\003\002\004\002\005\002\006\002\007\002\b\002\t\002\n\002\011\002\012\002\r\002\014\002\015\002\016\002\017\002\018\002\019\002\020\002\021\002\022\002\023\002\024\002\025\002\026\002\027\002\028\002\029\002\030\002\031\002 \002!\002\"\002#\002$\002%\002&\002'\002(\002)\002*\002+\002,\002-\002.\002/\0020\0021\0022\0023\0024\0025\0026\0027\0028\0029\002:\002;\002<\002=\002>\002?\002@\002A\002B\002C\002D\002E\002F\002G\002H\002I\002J\002K\002L\002M\002N\002O\002n\002o\002p\002q\002r\002s\002t\002u\002v\002w\002x\002y\002z\002{\002|\002}\002~\002\127\002\128\002\129\002\130\002V\002W\002X\002Y\002P\002Q\002T\002U\002\\\002]\002^\002_\002`\002a\002b\002c\002d\002e\002f\002g\002h\002i\002j\002k\002l\002m\002R\002S\002Z\002[\005\189\005\190\002\132\002\133\002\134\002\135\002\136\002\137\002\138\002\139\002\140\002\141\002\142\002\143\002\144\002\145\002\146\002\147\002\148\002\149\002\166\002\167\002\192\002\193\002\194\002\195\002\196\002\197\002\198\002\199\002\200\002\201\002\150\002\151\002\156\002\157\002\168\002\169\002\152\002\153\002\154\002\155\002\158\002\159\002\160\002\161\002\162\002\163\002\164\002\165\002\170\002\171\002\172\002\173\002\184\002\185\002\174\002\175\002\176\002\177\002\178\002\179\002\186\002\187\002\188\002\189\002\190\002\191\002\180\002\181\002\182\002\183\002\202\002\203\002\204\002\205\002\206\002\207\002\208\002\209\002\210\002\211\002\212\002\213\002\214\002\215\002\216\002\217\002\218\002\219\002\220\002\221\002\222\002\223\002\224\002\225\002\226\002\227\002\228\002\229\002\230\002\231\002\232\002\233\002\234\002\235\002\236\002\237\002\238\002\239\002\240\002\241\002\242\002\243\002\244\002\245\002\246\002\247\002\248\002\249\002\250\002\251\002\252\002\253\002\254\002\255\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\b\003\t\003\n\003\011\003\012\003\r\003\014\003\015\003\016\003\017\003\018\003\019\003\020\003\021\003\022\003\023\003\024\003\025\003\026\003\027\003\028\003\029\003\030\003\031\003 \003!\003\"\003#\003$\003%\003&\003'\003(\003)\003*\003+\003,\003-\003.\003/\0030\0031\0032\0033\0034\0035\0036\0037\0038\0039\003:\003;\003<\003=\003>\003?\003@\003A\003B\003C\003D\003E\003F\003G\003H\003I\003J\003K\003L\003M\003N\003O\003P\003Q\003R\003S\003T\003U\003V\003W\003X\003Y\003Z\003[\003\\\003]\003^\003_\003`\003a\003b\003c\003d\003e\003f\003g\003h\003i\003j\003k\003l\003m\003n\003o\003p\003q\003r\003s\003t\003u\003v\003w\003x\003y\003z\003{\003|\003}\003~\003\127\003\128\003\129\003\130\003\131\003\132\003\133\003\134\003\135\003\136\003\137\003\138\003\139\003\140\003\141\003\142\003\143\003\144\003\145\003\146\003\147\003\148\003\149\003\150\003\151\003\152\003\153\003\154\003\155\003\156\003\157\003\158\003\159\003\160\003\161\003\162\003\163\003\164\003\165\003\166\003\167\003\168\003\169\003\170\003\171\003\172\003\173\003\174\003\175\003\176\003\177\003\178\003\179\003\180\003\181\003\182\003\183\003\184\003\185\003\186\003\187\003\188\003\189\003\190\003\191\003\192\003\193\003\194\003\195\003\196\003\197\003\198\003\199\003\200\003\201\003\202\003\203\003\204\003\205\003\206\003\207\003\208\003\209\003\210\003\211\003\212\003\213\003\214\003\215\003\216\003\217\003\218\003\219\003\220\003\221\003\222\003\223\003\224\003\225\003\226\003\227\003\228\003\229\003\230\003\231\003\232\003\233\003\234\003\235\003\236\003\237\003\238\003\239\003\240\003\241\003\242\003\243\003\244\003\245\003\246\003\247\003\248\003\249\003\250\003\251\003\252\003\253\003\254\003\255\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\b\004\t\004\n\004\011\004\012\004\r\004\014\004\015\004\016\004\017\004\018\004\019\004\020\004\021\004\022\004\023\004\024\004\025\004\026\004\027\004\028\004\029\004\030\004\031\004 \004!\004\"\004#\004$\004%\004&\004'\004(\004)\004*\004+\004,\004-\004.\004/\0040\0041\0042\0043\0044\0045\0046\0047\0048\0049\004:\004;\004<\004=\004>\004?\004@\004A\004B\004C\004D\004E\004F\004G\004H\004I\004J\004K\004L\004M\004N\004O\004P\004Q\004R\004S\004T\004U\004V\004W\004X\004Y\004Z\004[\004\\\004]\004^\004_\004`\004a\004b\004c\004d\004e\004f\004g\004h\004i\004j\004k\004l\004m\004n\004o\004p\004q\004r\004s\004t\004u\004v\004w\004x\004y\004z\004{\004|\004}\004~\004\127\004\128\004\129\004\130\004\131\004\132\004\133\004\134\004\135\004\136\004\137\004\138\004\139\004\140\004\141\004\142\004\143\004\144\004\145\004\146\004\147\004\148\004\149\004\150\004\151\004\152\004\153\004\154\004\155\004\156\004\157\004\158\004\159\004\160\004\161\004\162\004\163\004\164\004\165\004\166\004\167\004\168\004\169\004\170\004\171\004\172\004\173\004\174\004\175\004\176\004\177\004\178\004\179\004\180\004\181\004\182\004\183\004\184\004\185\004\186\004\187\004\188\004\189\004\190\004\191\004\192\004\193\004\194\004\195\004\196\004\197\004\198\004\199\004\200\004\201\004\202\004\203\004\204\004\205\004\206\004\207\004\208\004\209\004\210\004\211\004\212\004\213\004\214\004\215\004\216\004\217\004\218\004\219\004\220\004\221\004\222\004\223\004\224\004\225\004\226\004\227\004\228\004\229\004\230\004\231\004\232\004\233\004\234\004\235\004\236\004\237\004\238\004\239\004\240\004\241\004\242\004\243\004\244\004\245\004\246\004\247\004\248\004\249\004\250\004\251\004\252\004\253\004\254\004\255\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\b\005\t\005\n\005\011\005\012\005\r\005\014\005\015\005\016\005\017\005\018\005\019\005\020\005\021\005\022\005\023\005\024\005\025\005\026\005\027\005\028\005\029\005\030\005\031\005 \005!\005\"\005#\005$\005%\005&\005'\005(\005)\005*\005+\005,\005-\005.\005/\0050\0051\0052\0053\0054\0055\0056\0057\0058\0059\005:\005;\005<\005=\005>\005?\005@\005A\005B\005C\005D\005E\005F\005G\005H\005I\005J\005K\005L\005M\005N\005O\005P\005Q\005R\005S\005T\005U\005V\005W\005X\005Y\005Z\005[\005\191\005\192\005\193\005\194\005\195\005\196\005\197\005\198\005\199\005\200\005\201\005l\005m\005n\005\202\005\203\005\204\005\205\005\206\005\207\005\208\005\135\005\136\005\137\005\138\005\139\005\140\005\141\005\142\005\143\005\144\005\145\005\146\005\147\005\148\005\149\005\150\005\151\005\152\005\153\005\154\005\155\005\156\005\157\005\158\005\159\005\160\005\161\005\162\005\163\005\164\005\165\005\166\005\167\005\168\005\169\005\170\005\171\005\172\005\173\005\174\005\175\005\176\005\177\005\178\005\179\005\180\005\181\005\182\005\183\005\184\005\185\005\186\005\187\005\188\005\209\005\210\005\211\005\212\005\213\005\214\005\215\005\216\002\131\005\\\005]\005^\005_\005`\005a\005b\005c\005d\005e\005f\005g\005h\005i\005j\005k\005o\005p\005q\005r\005s\005t\005u\005v\005w\005x\005y\005z\005{\005|\005}\005~\005\127\005\128\005\129\005\130\005\131\005\132\005\133\005\134\005\217\005\218\005\219\005\220\005\221\005\222\005\223\005\224\005\225\005\226\005\227\005\228\005\229\005\230\005\231\005\232\005\233\005\234\005\235\005\236\005\237\005\238\005\239\005\240\005\241\005\242\005\243\005\244\005\245\005\246\005\247\005\248\005\249\005\250\005\251\005\252\005\253\005\254\005\255\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\b\006\t\006\n\006\011\006\012\006\r\006\014\006\015\006\016\006\017\006\018\006\019\006\020\006\021\006\022\006\023\006\024\006\025\006\026\006\027\006\028\006\029\006\030\006\031\006 \006!\006\"\006#\006$\006%\006&\006'\006(\006)\006*\006+\006,\006-\006.\006/\0060\0061\0062\0063\0064\0065\0066\0067\0068\0069\006:\006;\006<\006=\006>\006?\006@\006A\006B\006C\006D\006E\006F\006G\006H\006I\006J\006K\006L\006M\006N\006O\006P\006Q\006R\006S\006T\006U\006V\006W\006X\006Y\006Z\006[\006\\\006]\006^\006_\006`\006a\006b\006c\006d\006e\006f\006g\006h\006i\006j\006k\006l\006m\006n\006o\006p\006q\006r\006s\006t\006u\006v\006w\006x\006y\006z\006{\006|\006}\006~\006\127\006\128\006\129\006\130\006\131\006\132\006\133\006\134\006\135\006\136\006\137\006\138\006\139\006\140\006\141\006\142\006\143\006\144\006\145\006\146\006\147\006\148\006\149\006\150\006\151\006\152\006\153\006\154\006\155\006\156\006\157\006\158\006\159\006\160\006\161\006\162\006\163\006\164\006\165\006\166\006\167\006\168\006\169\006\170\006\171\006\172\006\173\006\174\006\175\006\176\006\177\006\178\006\179\006\180\006\181\006\182\006\183\006\184\006\185\006\186\006\187\006\188\006\189\006\190\006\191\006\192\006\193\006\194\006\195\006\196\006\197\006\198\006\199\006\200\006\201\006\202\006\203\006\204\006\205\006\206\006\207\006\208\006\209\006\210\006\211\006\212\006\213\006\214\006\215\006\216\006\217\006\218\006\219\006\220\006\221\006\222\006\223\006\224\006\225\006\226\006\227\006\228\006\229\006\230\006\231\006\232\006\233\006\234\006\235\006\236\006\237\006\238\006\239\006\240\006\241\006\242\006\243\006\244\006\245\006\246\006\247\006\248\006\249\006\250\006\251\006\252\006\253\006\254\006\255\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\b\007\t\007\n\007\011\007\012\007\r\007\014\007\015\007\016\007\017\007\018\007\019\007\020\007\021\007\022\007\023\007\024\007\025\007\026\007\027\007\028\007\029\007\030\007\031\007 \007!\007\"\007#\007$\007%\007&\007'\007(\007)\007*\007+\007,\007-\007.\007/\0070\0071\0072\0073\0074\0075\0076\0077\0078\0079\007:\007;\007<\007=\007>\007?\007@\007A\007B\007C\007D") + (16, "\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\b\000\t\000\n\000\011\000\012\000\r\000\014\000\015\000\016\000\017\000\018\000\019\000\020\000\021\000\022\000\023\000\024\000\025\000\026\000\027\000\028\000\029\000\030\000\031\000 \000!\000\"\000#\000$\000%\000&\000'\000(\000)\000*\000+\000,\000-\000.\000/\0000\0001\0002\0003\0004\0005\0006\0007\0008\0009\000:\000;\000<\000=\000>\000?\000@\000A\000B\000C\000D\000E\000F\000G\000H\000I\000J\000K\000L\000M\000N\000O\000P\000Q\000R\000S\000T\000U\000V\000W\000X\000Y\000Z\000[\000\\\000]\000^\000_\000`\000a\000b\000c\000d\000e\000f\000g\000h\000i\000j\000k\000l\000m\000n\000o\000p\000q\000r\000s\000t\000u\000v\000w\000x\000y\000z\000{\000|\000}\000~\000\127\000\128\000\129\000\130\000\131\000\132\000\133\000\134\000\135\000\136\000\137\000\138\000\139\000\140\000\141\000\142\000\143\000\144\000\145\000\146\000\147\000\148\000\149\000\150\000\151\000\152\000\153\000\154\000\155\000\156\000\157\000\158\000\159\000\160\000\161\000\162\000\163\000\164\000\165\000\166\000\167\000\168\000\169\000\170\000\171\000\172\000\173\000\174\000\175\000\176\000\177\000\178\000\179\000\180\000\181\000\182\000\183\000\184\000\185\000\186\000\187\000\188\000\189\000\190\000\191\000\192\000\193\000\194\000\195\000\196\000\197\000\198\000\199\000\200\000\201\000\202\000\203\000\204\000\205\000\206\000\207\000\208\000\209\000\210\000\211\000\212\000\213\000\214\000\215\000\216\000\217\000\218\000\219\000\220\000\221\000\222\000\223\000\224\000\225\000\226\000\227\000\228\000\229\000\230\000\231\000\232\000\233\000\234\000\235\000\236\000\237\000\238\000\239\000\240\000\241\000\242\000\243\000\244\000\245\000\246\000\247\000\248\000\249\000\250\000\251\000\252\000\253\000\254\000\255\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\b\001\t\001\n\001\011\001\012\001\r\001\014\001\015\001\016\001\017\001\018\001\019\001\020\001\021\001\022\001\023\001\024\001\025\001\026\001\027\001\028\001\029\001\030\001\031\001 \001!\001\"\001#\001$\001%\001&\001'\001(\001)\001*\001+\001,\001-\001.\001/\0010\0011\0012\0013\0014\0015\0016\0017\0018\0019\001:\001;\001<\001=\001>\001?\001@\001A\001B\001C\001D\001E\001F\001G\001H\001I\001J\001K\001L\001M\001N\001O\001P\001Q\001R\001S\001T\001U\001V\001W\001X\001Y\001Z\001[\001\\\001]\001^\001_\001`\001a\001b\001c\001d\001e\001f\001g\001h\001i\001j\001k\001l\001m\001n\001o\001p\001q\001r\001s\001t\001u\001v\001w\001x\001y\001z\001{\001|\001}\001\128\001\129\001\134\001\135\001\136\001\137\001\138\001\139\001\140\001\141\001\142\001\143\001\144\001\145\001\146\001\147\001\148\001\149\001\150\001\151\001\152\001~\001\127\001\153\001\154\001\155\001\130\001\131\001\132\001\133\001\156\001\157\001\158\001\159\001\160\001\161\001\162\001\163\001\164\001\165\001\166\001\167\001\168\001\169\001\170\001\171\001\172\001\173\001\174\001\175\001\176\001\177\001\178\001\179\001\180\001\181\001\182\001\183\001\184\001\185\001\186\001\187\001\188\001\189\001\190\001\191\001\192\001\193\001\194\001\195\001\196\001\197\001\198\001\199\001\200\001\201\001\202\001\203\001\204\001\205\001\206\001\207\001\208\001\209\001\210\001\211\001\212\001\213\001\214\001\215\001\216\001\217\001\218\001\219\001\220\001\221\001\222\001\223\001\224\001\225\001\226\001\227\001\228\001\229\001\230\001\231\001\232\001\233\001\234\001\235\001\238\001\239\001\240\001\241\001\242\001\243\001\244\001\245\001\246\001\247\001\236\001\237\001\248\001\249\001\250\001\251\001\252\001\253\001\254\001\255\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\b\002\t\002\n\002\011\002\012\002\r\002\014\002\015\002\016\002\017\002\018\002\019\002\020\002\021\002\022\002\023\002\024\002\025\002\026\002\027\002\028\002\029\002\030\002\031\002 \002!\002\"\002#\002$\002%\002&\002'\002(\002)\002*\002+\002,\002-\002.\002/\0020\0021\0022\0023\0024\0025\0026\0027\0028\0029\002:\002;\002<\002=\002>\002?\002@\002A\002B\002C\002D\002E\002F\002G\002H\002I\002J\002K\002L\002M\002N\002O\002P\002Q\002R\002S\002T\002U\002V\002W\002X\002Y\002Z\002[\002\\\002]\002^\002_\002`\002a\002\137\002\138\002\139\002\140\002\141\002\142\002\143\002\144\002\145\002\146\002\147\002\148\002\149\002\150\002\151\002\152\002\153\002\154\002\155\002\156\002\157\002m\002n\002o\002p\002b\002c\002f\002g\002h\002i\002j\002k\002l\002s\002t\002u\002v\002w\002x\002y\002z\002{\002|\002}\002~\002\127\002\128\002\129\002\130\002\131\002\132\002\133\002\134\002\135\002\136\002d\002e\002q\002r\004\t\004\n\002\159\002\160\002\161\002\162\002\163\002\164\002\165\002\166\002\167\002\168\002\169\002\170\002\171\002\172\002\173\002\174\002\175\002\176\002\177\002\178\002\179\002\180\002\181\002\230\002\231\002\232\002\233\002\234\002\235\0034\0035\0036\0037\0038\0039\003:\003;\003<\003=\003>\003?\003@\003A\002\182\002\183\002\184\002\185\002\186\002\187\002\200\002\201\002\202\002\203\002\204\002\205\002\236\002\237\002\238\002\239\002\240\002\241\002\188\002\189\002\190\002\191\002\192\002\193\002\194\002\195\002\196\002\197\002\198\002\199\002\206\002\207\002\208\002\209\002\210\002\211\002\212\002\213\002\214\002\215\002\216\002\217\002\218\002\219\002\220\002\221\002\222\002\223\002\224\002\225\002\226\002\227\002\228\002\229\002\242\002\243\002\244\002\245\002\246\002\247\002\248\002\249\002\250\002\251\002\252\002\253\003\028\003\029\003\030\003\031\003 \003!\002\254\002\255\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\b\003\t\003\n\003\011\003\012\003\r\003\014\003\015\003\"\003#\003$\003%\003&\003'\003(\003)\003*\003+\003,\003-\003.\003/\0030\0031\0032\0033\003\016\003\017\003\018\003\019\003\020\003\021\003\022\003\023\003\024\003\025\003\026\003\027\003B\003C\003D\003E\003F\003G\003H\003I\003J\003K\003L\003M\003N\003O\003P\003Q\003R\003S\003T\003U\003V\003W\003X\003Y\003Z\003[\003\\\003]\003^\003_\003`\003a\003b\003c\003d\003e\003f\003g\003h\003i\003j\003k\003l\003m\003n\003o\003p\003q\003r\003s\003t\003u\003v\003w\003x\003y\003z\003{\004\011\004\012\004\r\004\014\004\015\004\016\004\017\004\018\004\019\004\020\004\021\003\140\003\141\003\142\004\022\004\023\004\024\004\025\004\026\004\027\004\028\003\166\003\167\003\168\003\169\003\170\003\171\003\172\003\173\003\174\003\175\003\176\003\177\003\178\003\179\003\180\003\181\003\182\003\183\003\184\003\185\003\186\003\187\003\188\003\189\003\190\003\191\003\192\003\193\003\194\003\195\003\196\003\197\003\198\003\199\003\200\003\201\003\202\003\203\003\204\003\205\003\206\003\207\003\208\003\209\003\210\003\211\003\212\003\213\003\214\003\215\003\216\003\217\003\218\003\219\003\220\003\221\003\222\003\223\003\224\003\225\003\226\003\227\003\228\003\229\003\230\003\231\003\232\003\233\003\234\003\235\003\236\003\237\003\238\003\239\003\240\003\241\003\242\003\243\003\244\003\245\003\246\003\247\003\248\003\249\003\250\003\251\003\252\003\253\003\254\003\255\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\b\004\029\004\030\004\031\004 \004!\004\"\004#\004$\004%\002\158\003|\003}\003~\003\127\003\128\003\129\003\130\003\131\003\132\003\133\003\134\003\135\003\136\003\137\003\138\003\139\003\143\003\144\003\145\003\146\003\147\003\148\003\149\003\150\003\151\003\152\003\153\003\154\003\155\003\156\003\157\003\158\003\159\003\160\003\161\003\162\003\163\003\164\003\165\004&\004'\004(\004)\004*\004+\004,\004-\004.\004/\0040\0041\0042\0043\0044\0045\0046\0047\0048\0049\004:\004;\004<\004=\004>\004?\004@\004A\004B\004C\004D\004E\004F\004G\004H\004I\004J\004K\004L\004M\004N\004O\004P\004Q\004R\004S\004T\004U\004V\004W\004X\004Y\004Z\004[\004\\\004]\004^\004_\004`\004a\004b\004c\004d\004e\004f\004g\004h\004i\004j\004k\004l\004m\004n\004o\004p\004q\004r\004s\004t\004u\004v\004w\004x\004y\004z\004{\004|\004}\004~\004\127\004\128\004\129\004\130\004\131\004\132\004\133\004\134\004\135\004\136\004\137\004\138\004\139\004\140\004\141\004\142\004\143\004\144\004\145\004\146\004\147\004\148\004\149\004\150\004\151\004\152\004\153\004\154\004\155\004\156\004\157\004\158\004\159\004\160\004\161\004\162\004\163\004\164\004\165\004\166\004\167\004\168\004\169\004\170\004\171\004\172\004\173\004\174\004\175\004\176\004\177\004\178\004\179\004\180\004\181\004\182\004\183\004\184\004\185\004\186\004\187\004\188\004\189\004\190\004\191\004\192\004\193\004\194\004\195\004\196\004\197\004\198\004\199\004\200\004\201\004\202\004\203\004\204\004\205\004\206\004\207\004\208\004\209\004\210\004\211\004\212\004\213\004\214\004\215\004\216\004\217\004\218\004\219\004\220\004\221\004\222\004\223\004\224\004\225\004\226\004\227\004\228\004\229\004\230\004\231\004\232\004\233\004\234\004\235\004\236\004\237\004\238\004\239\004\240\004\241\004\242\004\243\004\244\004\245\004\246\004\247\004\248\004\249\004\250\004\251\004\252\004\253\004\254\004\255\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\b\005\t\005\n\005\011\005\012\005\r\005\014\005\015\005\016\005\017\005\018\005\019\005\020\005\021\005\022\005\023\005\024\005\025\005\026\005\027\005\028\005\029\005\030\005\031\005 \005!\005\"\005#\005$\005%\005&\005'\005(\005)\005*\005+\005,\005-\005.\005/\0050\0051\0052\0053\0054\0055\0056\0057\0058\0059\005:\005;\005<\005=\005>\005?\005@\005A\005B\005C\005D\005E\005F\005G\005H\005I\005J\005K\005L\005M\005N\005O\005P\005Q\005R\005S\005T\005U\005V\005W\005X\005Y\005Z\005[\005\\\005]\005^\005_\005`\005a\005b\005c\005d\005e\005f\005g\005h\005i\005j\005k\005l\005m\005n\005o\005p\005q\005r\005s\005t\005u\005v\005w\005x\005y\005z\005{\005|\005}\005~\005\127\005\128\005\129\005\130\005\131\005\132\005\133\005\134\005\135\005\136\005\137\005\138\005\139\005\140\005\141\005\142\005\143\005\144\005\145\005\146\005\147\005\148\005\149\005\150\005\151\005\152\005\153\005\154\005\155\005\156\005\157\005\158\005\159\005\160\005\161\005\162\005\163\005\164\005\165\005\166\005\167\005\168\005\169\005\170\005\171\005\172\005\173\005\174\005\175\005\176\005\177\005\178\005\179\005\180\005\181\005\182\005\183\005\184\005\185\005\186\005\187\005\188\005\189\005\190\005\191\005\192\005\193\005\194\005\195\005\196\005\197\005\198\005\199\005\200\005\201\005\202\005\203\005\204\005\205\005\206\005\207\005\208\005\209\005\210\005\211\005\212\005\213\005\214\005\215\005\216\005\217\005\218\005\219\005\220\005\221\005\222\005\223\005\224\005\225\005\226\005\227\005\228\005\229\005\230\005\231\005\232\005\233\005\234\005\235\005\236\005\237\005\238\005\239\005\240\005\241\005\242\005\243\005\244\005\245\005\246\005\247\005\248\005\249\005\250\005\251\005\252\005\253\005\254\005\255\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\b\006\t\006\n\006\011\006\012\006\r\006\014\006\015\006\016\006\017\006\018\006\019\006\020\006\021\006\022\006\023\006\024\006\025\006\026\006\027\006\028\006\029\006\030\006\031\006 \006!\006\"\006#\006$\006%\006&\006'\006(\006)\006*\006+\006,\006-\006.\006/\0060\0061\0062\0063\0064\0065\0066\0067\0068\0069\006:\006;\006<\006=\006>\006?\006@\006A\006B\006C\006D\006E\006F\006G\006H\006I\006J\006K\006L\006M\006N\006O\006P\006Q\006R\006S\006T\006U\006V\006W\006X\006Y\006Z\006[\006\\\006]\006^\006_\006`\006a\006b\006c\006d\006e\006f\006g\006h\006i\006j\006k\006l\006m\006n\006o\006p\006q\006r\006s\006t\006u\006v\006w\006x\006y\006z\006{\006|\006}\006~\006\127\006\128\006\129\006\130\006\131\006\132\006\133\006\134\006\135\006\136\006\137\006\138\006\139\006\140\006\141\006\142\006\143\006\144\006\145\006\146\006\147\006\148\006\149\006\150\006\151\006\152\006\153\006\154\006\155\006\156\006\157\006\158\006\159\006\160\006\161\006\162\006\163\006\164\006\165\006\166\006\167\006\168\006\169\006\170\006\171\006\172\006\173\006\174\006\175\006\176\006\177\006\178\006\179\006\180\006\181\006\182\006\183\006\184\006\185\006\186\006\187\006\188\006\189\006\190\006\191\006\192\006\193\006\194\006\195\006\196\006\197\006\198\006\199\006\200\006\201\006\202\006\203\006\204\006\205\006\206\006\207\006\208\006\209\006\210\006\211\006\212\006\213\006\214\006\215\006\216\006\217\006\218\006\219\006\220\006\221\006\222\006\223\006\224\006\225\006\226\006\227\006\228\006\229\006\230\006\231\006\232\006\233\006\234\006\235\006\236\006\237\006\238\006\239\006\240\006\241\006\242\006\243\006\244\006\245\006\246\006\247\006\248\006\249\006\250\006\251\006\252\006\253\006\254\006\255\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\b\007\t\007\n\007\011\007\012\007\r\007\014\007\015\007\016\007\017\007\018\007\019\007\020\007\021\007\022\007\023\007\024\007\025\007\026\007\027\007\028\007\029\007\030\007\031\007 \007!\007\"\007#\007$\007%\007&\007'\007(\007)\007*\007+\007,\007-\007.\007/\0070\0071\0072\0073\0074\0075\0076\0077\0078\0079\007:\007;\007<\007=\007>\007?\007@\007A\007B\007C\007D\007E\007F\007G\007H\007I\007J\007K\007L\007M\007N\007O\007P\007Q\007R\007S\007T\007U\007V\007W\007X\007Y\007Z\007[\007\\\007]\007^\007_\007`\007a\007b\007c\007d\007e\007f\007g\007h\007i\007j\007k\007l\007m\007n\007o\007p\007q\007r\007s\007t\007u\007v\007w\007x\007y\007z\007{\007|\007}\007~\007\127\007\128\007\129\007\130\007\131\007\132\007\133\007\134\007\135\007\136\007\137\007\138\007\139\007\140\007\141\007\142\007\143\007\144\007\145\007\146\007\147\007\148\007\149\007\150\007\151\007\152\007\153\007\154\007\155\007\156\007\157\007\158\007\159\007\160\007\161\007\162\007\163\007\164\007\165\007\166\007\167\007\168\007\169\007\170\007\171\007\172\007\173\007\174\007\175\007\176\007\177\007\178\007\179\007\180\007\181\007\182\007\183\007\184\007\185\007\186\007\187\007\188\007\189\007\190\007\191\007\192\007\193\007\194\007\195\007\196\007\197\007\198\007\199\007\200\007\201\007\202\007\203\007\204\007\205\007\206\007\207\007\208\007\209\007\210\007\211\007\212\007\213\007\214\007\215") and lr0_items = - ((32, "\000\000\000\000\000\001\252\001\000\002\240\001\000\011p\001\000\011l\001\000\011h\001\000\011d\001\000\011`\001\000\n\172\001\000\011\\\001\000\011X\001\000\011T\001\000\011P\001\000\011L\001\000\011H\001\000\011D\001\000\011@\001\000\011<\001\000\0118\001\000\0114\001\000\0110\001\000\011,\001\000\011(\001\000\011$\001\000\011 \001\000\011\028\001\000\011\024\001\000\011\020\001\000\n\168\001\000\011\016\001\000\011\012\001\000\011\b\001\000\011\004\001\000\011\000\001\000\n\252\001\000\n\248\001\000\n\244\001\000\n\240\001\000\n\236\001\000\n\232\001\000\n\228\001\000\n\224\001\000\n\220\001\000\n\216\001\000\n\212\001\000\n\208\001\000\n\204\001\000\n\200\001\000\n\196\001\000\n\192\001\000\n\188\001\000\n\184\001\000\n\180\001\000\n\176\001\000\000\172\001\000\000\168\001\000\000\172\002\000\000\172\003\000\002\240\002\000\001\252\002\000\000\176\001\000\000\176\002\000\0028\001\000\0028\002\000\0028\003\000\n0\001\000\005h\001\000\001\248\001\000\001\244\001\000\001\240\001\000\001\236\001\000\001\248\002\000\001\244\002\000\001\240\002\000\001\236\002\000\001\248\003\000\001\244\003\000\001\240\003\000\001\236\003\000\002,\001\000\002,\002\000\002,\003\000\001\156\001\000\001\136\001\000\002\248\001\000\n\b\001\000\t\244\001\000\t\244\002\000\t\244\003\000\001\016\001\000\001\012\001\000\nx\001\000\t\152\001\000\t\148\001\000\t\148\002\000\t\152\002\000\t\144\001\000\t\140\001\000\t\140\002\000\t\144\002\000\012x\001\000\n\160\001\000\nt\001\000\np\001\000\nh\001\000\001\180\001\000\001\148\001\000\006\196\001\000\001\148\002\000\006p\001\000\006\184\001\000\006\180\001\000\t\152\001\000\t\148\001\000\006\176\001\000\006\200\001\000\006\216\001\000\nt\002\000\np\002\000\nt\003\000\np\003\000\nt\004\000\np\004\000\005\192\001\000\005\188\001\000\nt\005\000\np\005\000\np\006\000\nt\006\000\0058\001\000\003t\001\000\005\200\001\000\005\200\002\000\012\156\001\000\012\156\002\000\012\156\003\000\012x\001\000\006\176\001\000\006\192\001\000\006\188\001\000\006t\001\000\006\208\001\000\006\172\001\000\006\168\001\000\006\164\001\000\006\160\001\000\006\156\001\000\006\148\001\000\006\212\001\000\006\204\001\000\006\144\001\000\006\140\001\000\006\136\001\000\006\132\001\000\006\128\001\000\006|\001\000\006\128\002\000\006|\002\000\003\132\001\000\003\132\002\000\006\128\003\000\006|\003\000\006\128\004\000\006|\004\000\006\128\005\000\006\136\002\000\006\132\002\000\006\136\003\000\006\132\003\000\006\136\004\000\006\132\004\000\006\136\005\000\006\144\002\000\006\140\002\000\006\144\003\000\006\140\003\000\006\144\004\000\006\140\004\000\006\144\005\000\006\232\001\000\006\220\001\000\006\152\001\000\006x\001\000\006\224\001\000\006\228\001\000\012x\002\000\012x\003\000\012|\001\000\012\156\004\000\012\156\005\000\000d\001\000\0058\001\000\b\144\001\000\000`\001\000\003t\001\000\003x\001\000\b\144\002\000\000`\002\000\007@\001\000\007@\002\000\007@\003\000\007<\001\000\000\132\001\000\000p\001\000\000\\\001\000\000X\001\000\000`\001\000\000`\002\000\000\\\002\000\000\\\003\000\000\\\004\000\005\208\001\000\005\208\002\000\005\208\003\000\005\208\004\000\005\184\001\000\005\152\001\000\005\152\002\000\011\176\001\000\011\172\001\000\003p\001\000\003l\001\000\011\176\002\000\011\172\002\000\003p\002\000\003l\002\000\011\176\003\000\011\172\003\000\003p\003\000\003l\003\000\012l\001\000\012X\001\000\012L\001\000\012X\002\000\011\176\004\000\003p\004\000\012`\001\000\012P\001\000\012`\002\000\012<\001\000\012h\001\000\012d\001\000\012\\\001\000\012T\001\000\012\\\002\000\012d\002\000\0120\001\000\012D\001\000\012@\001\000\012@\002\000\0120\002\000\b\196\001\000\012<\002\000\b\200\001\000\012<\003\000\b\200\002\000\b\200\003\000\011\176\005\000\003p\005\000\0050\001\000\003p\006\000\012(\001\000\0058\001\000\001\160\001\000\006T\001\000\006D\001\000\0064\001\000\006,\001\000\001\164\001\000\001\148\001\000\000\132\001\000\000p\001\000\000\\\001\000\000X\001\000\0050\001\000\0030\001\000\0030\002\000\0050\001\000\000x\001\000\000t\001\000\0050\001\000\005\b\001\000\005\000\001\000\004\248\001\000\005\b\002\000\005\000\002\000\004\248\002\000\002\244\001\000\002\244\002\000\004\156\001\000\004\152\001\000\003\144\001\000\000@\001\000\000<\001\000\006d\001\000\006`\001\000\006d\002\000\006d\003\000\006d\004\000\007X\001\000\007T\001\000\007P\001\000\007L\001\000\007H\001\000\007D\001\000\007X\002\000\007T\002\000\007P\002\000\007L\002\000\007X\003\000\007T\003\000\007P\003\000\007L\003\000\t\232\001\000\t\232\002\000\t\232\003\000\005`\001\000\005l\001\000\005d\001\000\005l\002\000\005d\002\000\005l\003\000\005d\003\000\005\128\001\000\001\b\001\000\t\232\004\000\004l\001\000\004l\002\000\011\216\001\000\011\212\001\000\001\232\001\000\001\232\002\000\001\232\003\000\002(\001\000\002(\002\000\002(\003\000\012x\001\000\t\240\001\000\t\236\001\000\t\184\001\000\t\180\001\000\001\180\001\000\001\148\001\000\n\b\001\000\006p\001\000\nD\001\000\n@\001\000\012|\001\000\002\188\001\000\002\188\002\000\004\224\001\000\004\224\002\000\004\224\003\000\b4\001\000\004\224\004\000\t\168\001\000\t\164\001\000\t\160\001\000\001\144\001\000\001\144\002\000\t\156\001\000\003\176\001\000\t\156\002\000\t\156\003\000\004\220\001\000\004\216\001\000\004\212\001\000\004\208\001\000\007\016\001\000\000\160\001\000\000\156\001\000\006\248\001\000\000\160\002\000\000\156\002\000\000\152\001\000\000\148\001\000\000\152\002\000\000\148\002\000\000\144\001\000\000\140\001\000\000\136\001\000\000|\001\000\005|\001\000\005<\001\000\0054\001\000\005|\002\000\005|\003\000\005|\001\000\005<\001\000\005|\004\000\005<\002\000\005<\003\000\005x\001\000\005<\002\000\0054\002\000\0054\003\000\001|\001\000\000|\002\000\000\140\002\000\006\020\001\000\006\020\002\000\000h\001\000\0034\001\000\003(\001\000\0034\002\000\012\020\001\000\b\228\001\000\b\228\002\000\012,\001\000\000\164\001\000\b\228\003\000\000\128\001\000\000l\001\000\000\128\002\000\000\128\003\000\000l\002\000\003,\001\000\003,\002\000\003,\003\000\003,\004\000\012\016\001\000\b\232\001\000\000\128\001\000\000l\001\000\b\232\002\000\b\232\003\000\000\128\001\000\000l\001\000\0034\003\000\b\236\001\000\b\180\001\000\b\184\001\000\000\140\003\000\000\140\004\000\b\184\002\000\b\184\003\000\011\224\001\000\011\220\001\000\011\220\002\000\006\236\001\000\011\220\003\000\011\220\004\000\b\168\001\000\b\168\002\000\000D\001\000\b\168\003\000\000H\001\000\000H\002\000\000H\003\000\000H\004\000\011\220\005\000\b\164\001\000\000H\001\000\011\224\002\000\b\240\001\000\001\216\001\000\001\216\002\000\001\212\001\000\000H\001\000\b\236\001\000\000\136\002\000\000\136\003\000\000\144\002\000\000\144\003\000\b\184\001\000\000\144\004\000\000\144\005\000\b\184\001\000\000\148\003\000\000\148\004\000\b\184\001\000\000\160\003\000\000\156\003\000\000\156\004\000\000\160\004\000\b\140\001\000\000\160\005\000\000\160\006\000\b\140\002\000\b\136\001\000\007\016\002\000\001\216\001\000\004\220\002\000\004\216\002\000\004\212\002\000\004\208\002\000\007(\001\000\007\196\001\000\007\196\002\000\007\196\003\000\001\128\001\000\n\140\001\000\n\140\002\000\001\140\001\000\001\152\001\000\001\132\001\000\n`\001\000\012\128\001\000\nd\001\000\007\196\004\000\nl\001\000\n\128\001\000\n|\001\000\n\128\002\000\n\128\003\000\t\136\001\000\n\136\001\000\n\156\001\000\n\152\001\000\n\148\001\000\n\144\001\000\005l\001\000\001\176\001\000\001\172\001\000\n\156\002\000\n\152\002\000\n\148\002\000\n\144\002\000\005l\002\000\001\176\002\000\n\156\003\000\n\152\003\000\001\176\003\000\n\152\004\000\007\160\001\000\007\160\002\000\007\160\003\000\007\180\001\000\007\144\001\000\007\164\001\000\007\152\001\000\007\164\002\000\007\168\001\000\007\164\003\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\007\168\002\000\007\168\003\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\007\136\002\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\003\000\007\136\001\000\007\156\002\000\007\168\001\000\007\156\003\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\007\148\002\000\007\148\003\000\007\140\002\000\n\136\001\000\007\192\001\000\007\192\002\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\n\164\001\000\n\132\001\000\007\188\001\000\007\184\001\000\012x\001\000\n\160\001\000\nt\001\000\np\001\000\nh\001\000\007\188\002\000\001\180\001\000\001\148\001\000\007\188\003\000\006\028\001\000\006\024\001\000\006\028\002\000\007\188\004\000\007\188\005\000\007\188\006\000\n\132\001\000\001\184\001\000\t\144\001\000\t\140\001\000\006\188\001\000\001\180\002\000\001\180\003\000\n\160\002\000\nh\002\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\nh\003\000\n\160\003\000\n\160\004\000\001\216\001\000\n\160\005\000\007\184\002\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\007\168\001\000\007\160\004\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\001\176\004\000\001\176\005\000\n\156\004\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\n\156\005\000\n\148\003\000\t\160\001\000\n\148\004\000\t\160\002\000\t\160\003\000\t\020\001\000\t\016\001\000\t\012\001\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\t\020\002\000\t\016\002\000\t\020\003\000\n\144\003\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\007(\002\000\004\220\003\000\004\216\003\000\004\212\003\000\004\208\003\000\004\220\004\000\004\216\004\000\004\212\004\000\004\216\005\000\007\000\001\000\004\216\006\000\004\220\005\000\t\168\002\000\t\164\002\000\t\164\003\000\n`\001\000\004\000\001\000\003\252\001\000\003\248\001\000\003\244\001\000\003\240\001\000\003\224\001\000\003\220\001\000\003\220\002\000\003\172\001\000\003\168\001\000\003\172\002\000\003\172\003\000\001\216\001\000\003\220\003\000\003\220\004\000\003\224\002\000\003\208\001\000\003\204\001\000\003\204\002\000\003\204\003\000\0070\001\000\002\180\001\000\n`\001\000\004,\001\000\004(\001\000\003\216\001\000\003\212\001\000\007\228\001\000\003\212\002\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\004$\001\000\004 \001\000\004$\002\000\004$\003\000\001\216\001\000\003\212\003\000\003\212\004\000\003\212\005\000\007\224\001\000\003\216\002\000\012x\001\000\011\132\001\000\n\160\001\000\nt\001\000\np\001\000\nh\001\000\001\180\001\000\001\148\001\000\011\132\002\000\011\132\003\000\011\132\004\000\003\228\001\000\003\228\002\000\011|\001\000\004\012\001\000\002\024\001\000\002\020\001\000\002\016\001\000\002\012\001\000\002\024\002\000\002\020\002\000\002\024\003\000\002\024\004\000\002\024\005\000\005\156\001\000\005\156\002\000\003<\001\000\0038\001\000\0038\002\000\003<\002\000\003<\003\000\005\212\001\000\005\204\001\000\005\204\002\000\b|\001\000\003@\001\000\b|\002\000\005\204\003\000\005\204\004\000\005\220\001\000\005\228\001\000\005\224\001\000\005\216\001\000\005\204\005\000\005\228\002\000\012\196\001\000\012\192\001\000\012\196\002\000\012\192\002\000\012\196\003\000\012\192\003\000\012\220\001\000\012\216\001\000\012\220\002\000\012\196\004\000\012\196\005\000\000H\001\000\012\192\004\000\012\192\005\000\000H\001\000\012\192\006\000\bt\001\000\bt\002\000\bt\003\000\001\216\001\000\bt\004\000\bt\005\000\001\216\001\000\0128\001\000\012\212\001\000\012\208\001\000\012\204\001\000\012\200\001\000\012\212\002\000\012\208\002\000\012\212\003\000\012\208\003\000\012\208\004\000\012\208\005\000\005\228\001\000\005\224\001\000\005\216\001\000\005\224\002\000\005\228\001\000\005\224\003\000\005\224\001\000\005\216\001\000\005\216\002\000\005|\001\000\005\\\001\000\005<\001\000\005\\\002\000\005<\002\000\005<\003\000\003t\001\000\005\\\003\000\005\244\001\000\005X\001\000\005\232\001\000\012\212\004\000\012\212\005\000\005\228\001\000\005\224\001\000\005\216\001\000\012\204\002\000\012\200\002\000\005l\001\000\012\200\003\000\012\200\004\000\005|\001\000\005<\001\000\005l\002\000\012\204\003\000\012\204\004\000\005|\001\000\005<\001\000\b\172\001\000\b\176\001\000\005\228\003\000\b\176\002\000\b\176\003\000\bx\001\000\005\228\001\000\005\224\001\000\005\216\001\000\005\212\002\000\005\212\003\000\005\228\001\000\005\224\001\000\005\216\001\000\003<\004\000\003<\005\000\005\156\003\000\005\156\004\000\005\160\001\000\005\176\001\000\005\172\001\000\005\164\001\000\005\156\005\000\007X\001\000\007T\001\000\007P\001\000\007L\001\000\007H\001\000\007D\001\000\005\176\002\000\005\176\003\000\007H\002\000\007D\002\000\005\176\001\000\005\172\001\000\005\164\001\000\007H\003\000\007D\003\000\007D\004\000\005\228\001\000\005\224\001\000\005\216\001\000\007D\005\000\005\172\002\000\005\164\002\000\005\168\001\000\005l\001\000\005\180\001\000\005\176\001\000\005\172\001\000\005\164\001\000\002\024\006\000\002\024\007\000\nP\001\000\001\144\001\000\n\020\001\000\n\016\001\000\t\b\001\000\t\004\001\000\t\000\001\000\007\024\001\000\n8\001\000\012|\001\000\005`\001\000\t\176\001\000\t\172\001\000\002D\001\000\002D\002\000\002D\003\000\t\228\001\000\t\224\001\000\t\228\002\000\t\224\002\000\t\228\003\000\t\224\003\000\0024\001\000\0020\001\000\0024\002\000\0020\002\000\0024\003\000\0020\003\000\002\028\001\000\002\028\002\000\002\028\003\000\b\156\001\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\004\244\001\000\004\240\001\000\004\236\001\000\004\240\002\000\002$\001\000\002 \001\000\002$\002\000\002 \002\000\002$\003\000\002 \003\000\012x\001\000\n\160\001\000\nt\001\000\np\001\000\nh\001\000\002$\004\000\001\180\001\000\001\148\001\000\002$\005\000\002$\006\000\002$\007\000\003\024\001\000\002\004\001\000\002\000\001\000\002\004\002\000\002\000\002\000\002\004\003\000\002\000\003\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\002\004\004\000\002\000\004\000\002\004\005\000\002<\001\000\002<\002\000\002<\003\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\002<\004\000\002<\005\000\n\012\001\000\t\248\001\000\005p\001\000\n(\001\000\n$\001\000\n\024\001\000\n\012\002\000\t\220\001\000\t\216\001\000\t\212\001\000\t\208\001\000\t\204\001\000\t\200\001\000\t\196\001\000\t\192\001\000\t\188\001\000\n(\002\000\n(\003\000\n(\001\000\n$\001\000\n\024\001\000\t\220\001\000\t\216\001\000\t\212\001\000\t\208\001\000\t\204\001\000\t\200\001\000\t\196\001\000\t\192\001\000\t\188\001\000\n$\002\000\n$\003\000\t\216\002\000\t\208\002\000\t\200\002\000\t\200\003\000\002@\001\000\002@\002\000\002@\003\000\n(\001\000\n$\001\000\n\024\001\000\t\220\001\000\t\216\001\000\t\212\001\000\t\208\001\000\t\204\001\000\t\200\001\000\t\196\001\000\t\192\001\000\t\188\001\000\002@\004\000\n\024\002\000\t\220\002\000\t\212\002\000\t\204\002\000\t\196\002\000\t\192\002\000\t\188\002\000\t\188\003\000\002\168\001\000\n(\001\000\n$\001\000\n\024\001\000\t\220\001\000\t\216\001\000\t\212\001\000\t\208\001\000\t\204\001\000\t\200\001\000\t\196\001\000\t\192\001\000\t\188\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002H\001\000\002\b\001\000\003\192\001\000\003\188\001\000\003\192\002\000\003\192\003\000\012 \001\000\012 \002\000\001\216\001\000\012\028\001\000\012\024\001\000\012\028\002\000\012\024\002\000\001\216\001\000\012\028\003\000\012\028\004\000\001\216\001\000\003\192\004\000\003\192\005\000\003\188\002\000\003\196\001\000\003\196\002\000\003\200\001\000\n(\001\000\n$\001\000\n\024\001\000\t\220\001\000\t\216\001\000\t\212\001\000\t\208\001\000\t\204\001\000\t\200\001\000\t\196\001\000\t\192\001\000\t\188\001\000\003\200\002\000\n\004\001\000\n\\\001\000\nX\001\000\nT\001\000\nL\001\000\nH\001\000\n<\001\000\n4\001\000\n \001\000\n\028\001\000\005t\001\000\005l\001\000\001\176\001\000\001\172\001\000\n\\\002\000\nX\002\000\nT\002\000\nL\002\000\nH\002\000\n<\002\000\n4\002\000\n \002\000\n\028\002\000\005t\002\000\005l\002\000\001\176\002\000\012x\001\000\n\\\003\000\n4\003\000\n\028\003\000\001\176\003\000\n4\004\000\006\180\001\000\000@\001\000\006\176\001\000\000<\001\000\n\\\004\000\n\\\005\000\n\\\006\000\n\\\007\000\005\176\001\000\005\172\001\000\005\164\001\000\n\\\b\000\n\\\t\000\005\228\001\000\005\224\001\000\005\216\001\000\n\\\n\000\011\216\001\000\006\192\001\000\011\212\001\000\006\188\001\000\006t\001\000\002\180\001\000\007\180\001\000\0040\001\000\0040\002\000\0040\003\000\001\216\001\000\0040\004\000\0040\005\000\b\220\001\000\002L\001\000\b\220\002\000\n\004\001\000\002T\001\000\n(\001\000\n$\001\000\n\024\001\000\t\220\001\000\t\216\001\000\t\212\001\000\t\208\001\000\t\204\001\000\t\200\001\000\t\196\001\000\t\192\001\000\t\188\001\000\002T\002\000\012\132\001\000\n,\001\000\n\000\001\000\t\252\001\000\004\232\001\000\001\228\001\000\001\228\002\000\001\228\003\000\004\228\001\000\004\016\001\000\002\176\001\000\002\176\002\000\002\176\003\000\t0\001\000\t,\001\000\t(\001\000\t$\001\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002\128\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\003\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002t\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\003\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002p\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\003\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002l\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\003\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002\132\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\003\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002\148\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\003\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002|\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\003\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002x\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\003\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002\140\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\003\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002h\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\003\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002d\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\003\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002`\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\003\000\002`\001\000\002\\\001\000\002X\001\000\002\\\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\003\000\002\\\001\000\002X\001\000\002X\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\003\000\002X\001\000\002\144\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\003\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002\136\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\003\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\b\224\002\000\b\224\003\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002\164\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\003\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002\184\002\000\b\224\001\000\002\232\001\000\002\184\003\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002\152\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\003\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002\156\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\003\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002\160\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\003\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\002\232\002\000\n\000\001\000\002P\001\000\n(\001\000\n$\001\000\n\024\001\000\t\220\001\000\t\216\001\000\t\212\001\000\t\208\001\000\t\204\001\000\t\200\001\000\t\196\001\000\t\192\001\000\t\188\001\000\002P\002\000\002\172\001\000\b\224\001\000\002\232\001\000\002\184\001\000\002\172\002\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\t0\002\000\t,\002\000\t(\002\000\t0\003\000\t0\004\000\t0\005\000\t,\003\000\000L\001\000\000L\002\000\nd\001\000\004\b\001\000\004\b\002\000\004\b\003\000\001\216\001\000\004\b\004\000\004\b\005\000\007\220\001\000\007\212\001\000\007\204\001\000\007\200\001\000\007\176\001\000\004\004\001\000\004\004\002\000\004\004\003\000\007\176\002\000\007\176\003\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\007\200\002\000\007\200\003\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\007\220\002\000\007\220\003\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\007\212\002\000\007\212\003\000\007\204\002\000\007\208\001\000\007\216\001\000\007\172\001\000\007\172\002\000\007\172\003\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\003\236\001\000\000L\003\000\b\012\001\000\b\012\002\000\007\248\001\000\007\244\001\000\007\248\002\000\007\244\002\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\007\248\003\000\007\248\004\000\011\188\001\000\011\184\001\000\005\236\001\000\005\236\002\000\005\236\003\000\005\236\004\000\005\236\005\000\007 \001\000\007 \002\000\005\228\001\000\005\224\001\000\005\216\001\000\005\236\006\000\004\132\001\000\004\132\002\000\005\236\007\000\011\188\002\000\011\184\002\000\011\188\003\000\011\184\003\000\011\188\004\000\011\188\005\000\005\132\001\000\005\176\001\000\005\172\001\000\005\164\001\000\005\132\002\000\005\136\001\000\005\228\001\000\005\224\001\000\005\216\001\000\005\136\002\000\005\136\003\000\005\176\001\000\005\172\001\000\005\164\001\000\005\136\004\000\011\188\006\000\011\188\007\000\004\\\001\000\004\\\002\000\004\\\003\000\004\\\004\000\004\\\005\000\004\\\006\000\005\140\001\000\005\140\002\000\011\188\b\000\011\184\004\000\011\184\005\000\011\184\006\000\003\140\001\000\003\140\002\000\003\004\001\000\003\004\002\000\011\208\001\000\011\208\002\000\011\208\003\000\011\208\004\000\005\176\001\000\005\172\001\000\005\164\001\000\011\208\005\000\b\016\001\000\b\016\002\000\b\016\003\000\b\016\004\000\b\016\005\000\b\148\001\000\b\000\001\000\b\148\002\000\b\148\003\000\b\000\002\000\b\000\003\000\001\216\001\000\b\016\006\000\b\016\007\000\006$\001\000\006 \001\000\006$\002\000\b\016\b\000\b\016\t\000\007\252\001\000\001\216\001\000\011x\001\000\t4\001\000\011x\002\000\t4\002\000\011x\003\000\t4\003\000\001\160\001\000\001\164\001\000\001\148\001\000\001\164\002\000\001\164\003\000\001\144\001\000\011x\004\000\t4\004\000\003H\001\000\001\200\001\000\005\252\001\000\003\152\001\000\003\148\001\000\003\152\002\000\003\148\002\000\003\152\003\000\003\148\003\000\b\148\001\000\b\b\001\000\b\b\002\000\b\b\003\000\000H\001\000\003\152\004\000\003\148\004\000\003\152\005\000\003\148\005\000\003\152\006\000\003\152\007\000\b\004\001\000\000H\001\000\001\200\002\000\001\200\003\000\003\164\001\000\003\160\001\000\003\164\002\000\003\156\001\000\b\208\001\000\001\196\001\000\b\208\002\000\001\196\002\000\b\208\003\000\001\196\003\000\000\128\001\000\000l\001\000\003H\002\000\b\204\001\000\001\192\001\000\000\128\001\000\000l\001\000\011x\005\000\001\180\001\000\001\148\001\000\005l\001\000\001\176\001\000\001\172\001\000\005l\002\000\001\176\002\000\001\176\003\000\011x\006\000\011x\007\000\011x\b\000\003X\001\000\003T\001\000\003P\001\000\003L\001\000\b\148\001\000\003X\002\000\003P\002\000\003X\003\000\003P\003\000\003P\004\000\003P\005\000\003P\006\000\000\128\001\000\000l\001\000\b\204\001\000\003X\004\000\001\192\001\000\000\128\001\000\000l\001\000\003L\002\000\003L\003\000\003L\004\000\000\128\001\000\000l\001\000\b\204\001\000\003T\002\000\001\192\001\000\000\128\001\000\000l\001\000\t4\005\000\t4\006\000\t4\007\000\001\168\001\000\007\240\001\000\007\236\001\000\tX\001\000\tT\001\000\003p\001\000\003l\001\000\003h\001\000\003d\001\000\tX\002\000\tT\002\000\003p\002\000\003l\002\000\003h\002\000\003d\002\000\tX\003\000\tT\003\000\003p\003\000\003l\003\000\003h\003\000\003d\003\000\tX\004\000\003p\004\000\003h\004\000\tX\005\000\003p\005\000\003h\005\000\0050\001\000\003p\006\000\003h\006\000\003h\007\000\001\144\001\000\000\144\001\000\000\140\001\000\000\136\001\000\006P\001\000\006P\002\000\006P\003\000\006@\001\000\003\\\001\000\001\204\001\000\003\\\002\000\003\\\003\000\003\\\004\000\bH\001\000\001\208\001\000\003\\\001\000\bH\002\000\003h\b\000\bt\001\000\003h\t\000\003h\n\000\b@\001\000\bD\001\000\006\\\001\000\006X\001\000\006L\001\000\006H\001\000\006<\001\000\0068\001\000\006(\001\000\001\216\001\000\006\\\002\000\006X\002\000\006L\002\000\006H\002\000\006<\002\000\0068\002\000\006\\\003\000\006L\003\000\006<\003\000\006\\\004\000\006\\\005\000\006\\\006\000\006L\004\000\006<\004\000\003`\001\000\003`\002\000\003`\003\000\006X\003\000\006X\004\000\006X\005\000\006H\003\000\0068\003\000\0060\001\000\003p\007\000\bt\001\000\003p\b\000\003p\t\000\tX\006\000\tX\007\000\b\024\001\000\tX\b\000\tX\t\000\bl\001\000\tX\n\000\bl\002\000\bd\001\000\bh\001\000\tT\004\000\003l\004\000\003d\004\000\0050\001\000\003l\005\000\003d\005\000\003d\006\000\003d\007\000\bt\001\000\003d\b\000\003d\t\000\003l\006\000\bt\001\000\003l\007\000\003l\b\000\tT\005\000\tT\006\000\tT\007\000\tT\b\000\bl\001\000\tT\t\000\004\140\001\000\006l\001\000\006h\001\000\006l\002\000\006l\003\000\006l\004\000\006l\005\000\005|\001\000\005<\001\000\006l\006\000\006h\002\000\006h\003\000\006h\004\000\005|\001\000\005<\001\000\006h\005\000\tl\001\000\td\001\000\t`\001\000\005\240\001\000\005\236\001\000\005\196\001\000\005\240\002\000\005\236\002\000\005\240\003\000\005\236\003\000\005\240\004\000\005\236\004\000\005\240\005\000\005\236\005\000\005\240\006\000\005\240\007\000\005\228\001\000\005\224\001\000\005\216\001\000\005\240\b\000\tl\002\000\td\002\000\t`\002\000\005\196\002\000\tl\003\000\td\003\000\t`\003\000\005\196\003\000\005\196\004\000\005\188\001\000\005\196\005\000\005\196\006\000\005|\001\000\005<\001\000\005\196\007\000\tl\004\000\tl\005\000\tl\006\000\tl\007\000\005\228\001\000\005\224\001\000\005\216\001\000\tl\b\000\004d\001\000\004d\002\000\004d\003\000\004d\004\000\005\228\001\000\005\224\001\000\005\216\001\000\004d\005\000\004d\006\000\004d\007\000\tl\t\000\td\004\000\t`\004\000\td\005\000\td\006\000\005l\001\000\td\007\000\005\144\001\000\005\228\001\000\005\224\001\000\005\216\001\000\005\144\002\000\t`\005\000\t`\006\000\005\148\001\000\005\148\002\000\t|\001\000\t|\002\000\t|\003\000\t|\004\000\005\228\001\000\005\224\001\000\005\216\001\000\t|\005\000\t4\001\000\t4\002\000\t4\003\000\t4\004\000\t\128\001\000\001x\001\000\001x\002\000\001x\003\000\001x\004\000\012\164\001\000\001x\005\000\003\012\001\000\b\200\001\000\003\012\002\000\003\012\003\000\001x\006\000\001x\007\000\001x\b\000\001D\001\000\001D\002\000\001\024\001\000\001\216\001\000\001\024\002\000\001\024\003\000\001D\003\000\001$\001\000\001$\002\000\006\016\001\000\006\b\001\000\006\016\002\000\006\012\001\000\006\004\001\000\006\012\002\000\001$\003\000\001$\004\000\001$\005\000\001\216\001\000\001$\006\000\001$\007\000\001(\001\000\001(\002\000\b,\001\000\b$\001\000\b,\002\000\b(\001\000\b \001\000\b(\002\000\001(\003\000\001(\004\000\001(\005\000\001(\006\000\001(\007\000\001 \001\000\001 \002\000\001P\001\000\001L\001\000\001P\002\000\001L\002\000\001P\003\000\001P\004\000\005l\001\000\001P\005\000\001P\006\000\001<\001\000\b\192\001\000\001<\002\000\001<\003\000\001<\004\000\b\192\002\000\b\192\003\000\001\216\001\000\b\188\001\000\001\216\001\000\001@\001\000\0018\001\000\001P\007\000\001H\001\000\001H\002\000\001L\003\000\005l\001\000\001L\004\000\001L\005\000\001L\006\000\001H\001\000\001H\001\000\001 \003\000\001 \004\000\001,\001\000\001,\002\000\001\216\001\000\001\188\001\000\001\188\002\000\001\216\001\000\001\188\003\000\001,\003\000\001,\004\000\001D\004\000\001D\005\000\0010\001\000\0010\002\000\0014\001\000\004\168\001\000\004\168\002\000\001x\t\000\001H\001\000\001x\n\000\004T\001\000\004T\002\000\004T\003\000\004T\004\000\004T\005\000\004T\006\000\004T\007\000\001H\001\000\004T\b\000\004T\t\000\001x\011\000\t\128\002\000\t\128\003\000\t\128\004\000\t\128\005\000\t\128\006\000\t\128\007\000\0050\001\000\001p\001\000\001p\002\000\001p\003\000\001p\004\000\001<\001\000\000\144\001\000\000\140\001\000\000\136\001\000\b\240\001\000\b\188\001\000\001\216\001\000\001t\001\000\001t\002\000\001l\001\000\001l\002\000\001l\003\000\012,\001\000\001|\001\000\001@\001\000\000\164\001\000\001l\004\000\001h\001\000\001H\001\000\001t\003\000\001p\005\000\t\128\b\000\t\128\t\000\004L\001\000\004L\002\000\004L\003\000\004L\004\000\004L\005\000\004L\006\000\004L\007\000\004L\b\000\004L\t\000\t\128\n\000\tD\001\000\004\144\001\000\t\\\001\000\tH\001\000\tx\001\000\tt\001\000\tp\001\000\th\001\000\004\144\002\000\t<\001\000\t<\002\000\tL\001\000\004t\001\000\004t\002\000\004t\003\000\004t\004\000\004t\005\000\bt\001\000\004t\006\000\004t\007\000\004t\b\000\tL\002\000\tP\001\000\004|\001\000\004|\002\000\004|\003\000\004|\004\000\004|\005\000\004|\006\000\bt\001\000\004|\007\000\004|\b\000\004|\t\000\tP\002\000\t@\001\000\t\132\001\000\004\140\002\000\007\236\002\000\t8\001\000\007\240\002\000\001\216\001\000\011\200\001\000\001x\001\000\011\200\002\000\011\200\003\000\011\200\004\000\011\200\005\000\011\200\006\000\000\244\001\000\001d\001\000\001d\002\000\001d\003\000\000\220\001\000\012\152\001\000\012\144\001\000\012\152\002\000\012\144\002\000\012\152\003\000\012\144\003\000\012\152\004\000\012\144\004\000\012\144\005\000\012\144\006\000\012\152\005\000\012\152\006\000\012\152\007\000\000\220\002\000\000\220\003\000\012\148\001\000\012\140\001\000\012\136\001\000\012\176\001\000\012\168\001\000\012\176\002\000\012\172\001\000\005\252\001\000\012\172\002\000\012\136\002\000\012\136\003\000\012\136\004\000\012\136\005\000\001\216\001\000\012\148\002\000\012\140\002\000\012\148\003\000\012\140\003\000\012\140\004\000\012\140\005\000\012\148\004\000\012\148\005\000\012\148\006\000\000\224\001\000\005,\001\000\005$\001\000\005\028\001\000\005,\002\000\005$\002\000\005\028\002\000\005,\003\000\005$\003\000\005\028\003\000\005,\004\000\005$\004\000\005\028\004\000\005,\005\000\005$\005\000\005,\006\000\005,\007\000\005,\b\000\005,\t\000\001\216\001\000\005,\n\000\005,\011\000\005$\006\000\005$\007\000\005$\b\000\005\028\005\000\003\232\001\000\011\128\001\000\003\020\001\000\003\020\002\000\003\020\003\000\003\016\001\000\011\128\002\000\000\224\002\000\000\224\003\000\005(\001\000\005 \001\000\005\024\001\000\005\020\001\000\012\188\001\000\012\180\001\000\012\188\002\000\012\184\001\000\b\024\001\000\012\184\002\000\005\020\002\000\005\020\003\000\005\020\004\000\005\020\005\000\005(\002\000\005 \002\000\005\024\002\000\005(\003\000\005 \003\000\005\024\003\000\005(\004\000\005 \004\000\005(\005\000\005(\006\000\005(\007\000\005(\b\000\001\216\001\000\005(\t\000\005(\n\000\005 \005\000\005 \006\000\005 \007\000\005\024\004\000\000\232\001\000\000\232\002\000\000\232\003\000\000\232\004\000\000\216\001\000\000\212\001\000\000\216\002\000\000\216\003\000\001`\001\000\001T\001\000\004\024\001\000\004\020\001\000\000\196\001\000\000\192\001\000\004\024\002\000\004\024\003\000\004\024\004\000\004\024\005\000\004\024\006\000\004\024\007\000\000\196\002\000\000\192\002\000\000\196\003\000\000\196\004\000\005l\001\000\000\196\005\000\000\196\006\000\001\\\001\000\b\192\001\000\001\\\002\000\001\\\003\000\001\\\004\000\000\184\001\000\000\184\002\000\001\004\001\000\001\000\001\000\001\000\002\000\004\028\001\000\000\188\001\000\000\188\002\000\000\208\001\000\000\204\001\000\000\180\001\000\003\184\001\000\n(\001\000\n$\001\000\n\024\001\000\t\220\001\000\t\216\001\000\t\212\001\000\t\208\001\000\t\204\001\000\t\200\001\000\t\196\001\000\t\192\001\000\t\188\001\000\003\184\002\000\n(\001\000\n$\001\000\n\024\001\000\t\220\001\000\t\216\001\000\t\212\001\000\t\208\001\000\t\204\001\000\t\200\001\000\t\196\001\000\t\192\001\000\t\188\001\000\003\180\001\000\b\132\001\000\000\204\002\000\b\132\002\000\b\128\001\000\001X\001\000\000\200\001\000\000\188\003\000\000\200\002\000\004\028\002\000\001\000\003\000\000\200\001\000\001\004\002\000\000\184\003\000\000\200\001\000\000\196\007\000\000\192\003\000\005l\001\000\000\192\004\000\000\192\005\000\000\200\001\000\000\192\006\000\004\020\002\000\004\020\003\000\004\020\004\000\004\020\005\000\001`\002\000\001T\002\000\000\200\001\000\001T\003\000\001`\003\000\001`\004\000\001`\005\000\000\216\004\000\000\200\001\000\007\b\001\000\007\b\002\000\000\216\005\000\000\216\006\000\000\212\002\000\000\212\003\000\000\200\001\000\000\212\004\000\000\212\005\000\000\228\001\000\000\228\002\000\000\228\003\000\000\228\004\000\001d\004\000\001d\005\000\000\236\001\000\000\236\002\000\000\240\001\000\004\176\001\000\004\176\002\000\000\244\002\000\000\200\001\000\000\248\001\000\000\248\002\000\000\248\003\000\000\248\004\000\000\200\001\000\000\252\001\000\000\252\002\000\011\200\007\000\011\200\b\000\004D\001\000\004D\002\000\004D\003\000\004D\004\000\004D\005\000\004D\006\000\004D\007\000\004D\b\000\011\200\t\000\011\164\001\000\004\160\001\000\004\012\001\000\004\012\002\000\004\012\003\000\004\012\004\000\004\012\005\000\004\012\006\000\011\180\001\000\011t\001\000\011\160\001\000\011\196\001\000\011\192\001\000\011\144\001\000\004\232\001\000\004\232\002\000\004\160\002\000\011\148\001\000\004\016\001\000\004\016\002\000\011\152\001\000\011\152\002\000\011\168\001\000\011\168\002\000\011\156\001\000\011\204\001\000\007\232\001\000\011\140\001\000\011\140\002\000\011\140\003\000\003\004\003\000\003\004\004\000\011\144\001\000\004\232\001\000\001\228\001\000\011\136\001\000\011\148\001\000\004\016\001\000\002\176\001\000\003\140\003\000\003\140\004\000\b\012\003\000\b\012\004\000\000L\004\000\b\224\001\000\b\220\003\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\007\220\001\000\007\212\001\000\007\204\001\000\007\200\001\000\007\176\001\000\0044\001\000\0044\002\000\0044\003\000\004<\001\000\002\180\002\000\002\180\003\000\002\180\004\000\004<\002\000\004<\003\000\0048\001\000\n\012\001\000\006\152\001\000\n\028\004\000\n\028\005\000\nL\003\000\nH\003\000\nL\004\000\nH\004\000\nH\005\000\b\252\001\000\b\248\001\000\b\244\001\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\b\252\002\000\b\248\002\000\b\252\003\000\nX\003\000\nT\003\000\nX\004\000\nT\004\000\nT\005\000\n \003\000\n \004\000\n \005\000\n<\003\000\n(\001\000\n$\001\000\n\024\001\000\t\220\001\000\t\216\001\000\t\212\001\000\t\208\001\000\t\204\001\000\t\200\001\000\t\196\001\000\t\192\001\000\t\188\001\000\b<\001\000\b<\002\000\b<\003\000\t \001\000\t\028\001\000\t\024\001\000\0078\001\000\t \002\000\t\028\002\000\t\024\002\000\t \003\000\t\028\003\000\t\024\003\000\t \004\000\t\028\004\000\t \005\000\b8\001\000\n<\004\000\n<\005\000\n\\\001\000\nX\001\000\nT\001\000\nL\001\000\nH\001\000\n<\001\000\n4\001\000\n \001\000\n\028\001\000\005t\001\000\005l\001\000\005d\001\000\001\176\001\000\001\172\001\000\n\\\002\000\nX\002\000\nT\002\000\nL\002\000\nH\002\000\n<\002\000\n4\002\000\n \002\000\n\028\002\000\005t\002\000\005l\002\000\005d\002\000\001\176\002\000\012|\001\000\005d\003\000\005t\003\000\t\216\002\000\t\208\002\000\t\200\002\000\002\224\002\000\002\216\002\000\002\208\002\000\t\200\003\000\002\208\003\000\t\200\004\000\002\208\004\000\t\200\005\000\002\208\005\000\002\208\006\000\b\224\001\000\002\232\001\000\002\208\007\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\t\216\003\000\002\224\003\000\t\216\004\000\002\224\004\000\t\216\005\000\002\224\005\000\002\224\006\000\b\224\001\000\002\232\001\000\002\224\007\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\t\208\003\000\002\216\003\000\t\208\004\000\002\216\004\000\t\208\005\000\002\216\005\000\002\216\006\000\b\224\001\000\002\232\001\000\002\216\007\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\n\024\002\000\t\220\002\000\t\212\002\000\t\204\002\000\t\196\002\000\t\192\002\000\t\188\002\000\002\228\002\000\002\220\002\000\002\212\002\000\002\204\002\000\002\200\002\000\002\196\002\000\002\192\002\000\t\188\003\000\002\196\003\000\t\188\004\000\002\196\004\000\t\188\005\000\002\196\005\000\002\196\006\000\b\224\001\000\002\232\001\000\002\196\007\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\t\196\003\000\002\204\003\000\t\196\004\000\002\204\004\000\t\196\005\000\002\204\005\000\002\204\006\000\b\224\001\000\002\232\001\000\002\204\007\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\t\192\003\000\002\200\003\000\t\192\004\000\002\200\004\000\t\192\005\000\002\200\005\000\002\200\006\000\b\224\001\000\002\232\001\000\002\200\007\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\t\220\003\000\t\212\003\000\t\204\003\000\005l\001\000\005d\001\000\002\228\003\000\002\220\003\000\002\212\003\000\t\220\004\000\t\212\004\000\t\204\004\000\002\228\004\000\002\220\004\000\002\212\004\000\t\204\005\000\002\212\005\000\t\204\006\000\002\212\006\000\t\204\007\000\002\212\007\000\002\212\b\000\b\224\001\000\002\232\001\000\002\212\t\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\t\220\005\000\002\228\005\000\t\220\006\000\002\228\006\000\t\220\007\000\002\228\007\000\002\228\b\000\b\224\001\000\002\232\001\000\002\228\t\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\t\212\005\000\002\220\005\000\t\212\006\000\002\220\006\000\t\212\007\000\002\220\007\000\002\220\b\000\b\224\001\000\002\232\001\000\002\220\t\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\n\024\003\000\002\192\003\000\002\192\004\000\b\224\001\000\002\232\001\000\002\192\005\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\b\132\001\000\002H\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\168\002\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\t\188\004\000\t\188\005\000\t\196\003\000\t\196\004\000\t\196\005\000\t\192\003\000\t\192\004\000\t\192\005\000\t\220\003\000\t\212\003\000\t\204\003\000\005l\001\000\005d\001\000\t\220\004\000\t\212\004\000\t\204\004\000\t\204\005\000\t\204\006\000\t\204\007\000\t\220\005\000\t\220\006\000\t\220\007\000\t\212\005\000\t\212\006\000\t\212\007\000\n\024\003\000\t\200\004\000\t\200\005\000\t\216\003\000\t\216\004\000\t\216\005\000\t\208\003\000\t\208\004\000\t\208\005\000\002<\006\000\001\220\001\000\001\224\001\000\002<\007\000\002<\b\000\002<\t\000\002<\n\000\002<\011\000\002\004\006\000\002\004\007\000\002\004\b\000\002\004\t\000\002\000\005\000\002\000\006\000\002\000\007\000\002\000\b\000\002\000\t\000\002\000\n\000\002\000\011\000\003\024\002\000\012x\001\000\n\160\001\000\nt\001\000\np\001\000\nh\001\000\003$\001\000\001\180\001\000\001\148\001\000\003$\002\000\003$\003\000\003$\004\000\003\028\001\000\003\028\002\000\000\128\001\000\000l\001\000\003\028\003\000\003\028\004\000\003 \001\000\003 \002\000\003$\005\000\002$\b\000\002 \004\000\002 \005\000\004\240\003\000\004\240\004\000\004\240\005\000\004\244\002\000\004\236\002\000\004\244\003\000\004\236\003\000\b\156\002\000\b\160\001\000\002\028\004\000\b\160\002\000\b\160\003\000\b\152\001\000\0024\004\000\0020\004\000\0024\005\000\0020\005\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\0024\006\000\0020\006\000\0020\007\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\0020\b\000\t\228\004\000\t\224\004\000\t\224\005\000\n(\001\000\n$\001\000\n\024\001\000\t\220\001\000\t\216\001\000\t\212\001\000\t\208\001\000\t\204\001\000\t\200\001\000\t\196\001\000\t\192\001\000\t\188\001\000\002D\004\000\t\172\002\000\b\224\001\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\t\172\003\000\n(\001\000\n$\001\000\n\024\001\000\t\220\001\000\t\216\001\000\t\212\001\000\t\208\001\000\t\204\001\000\t\200\001\000\t\196\001\000\t\192\001\000\t\188\001\000\t\176\002\000\n8\002\000\n8\003\000\b\224\001\000\007\024\002\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\t\b\002\000\t\004\002\000\t\000\002\000\t\b\003\000\t\004\003\000\t\b\004\000\n\020\002\000\n\016\002\000\n\016\003\000\nP\002\000\nP\003\000\002\024\b\000\002\020\003\000\002\020\004\000\005\176\001\000\005\172\001\000\005\164\001\000\002\020\005\000\002\020\006\000\002\020\007\000\002\012\002\000\002\012\003\000\002\012\004\000\002\012\005\000\002\012\006\000\002\012\007\000\002\012\b\000\002\016\002\000\002\016\003\000\002\016\004\000\002\016\005\000\002\016\006\000\002\016\007\000\002\016\b\000\002\016\t\000\011|\002\000\011\132\005\000\004(\002\000\0070\002\000\003\204\004\000\003\204\005\000\003\208\002\000\012\028\001\000\012\024\001\000\004\000\002\000\003\252\002\000\004\000\003\000\004\000\004\000\004\000\005\000\004\000\006\000\001\216\001\000\004\000\007\000\004\000\b\000\b\148\001\000\003\252\003\000\003\252\004\000\003\252\005\000\001\216\001\000\003\252\006\000\003\252\007\000\003\248\002\000\003\248\003\000\003\248\004\000\003\244\002\000\004\224\005\000\004\224\006\000\b\224\001\000\002\232\001\000\002\188\003\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\nD\002\000\n@\002\000\n@\003\000\n(\001\000\n$\001\000\n\024\001\000\n\b\002\000\t\220\001\000\t\216\001\000\t\212\001\000\t\208\001\000\t\204\001\000\t\200\001\000\t\196\001\000\t\192\001\000\t\188\001\000\t\240\002\000\t\236\002\000\t\240\003\000\t\236\003\000\t\240\004\000\t\236\004\000\t\240\005\000\t\236\005\000\005\176\001\000\005\172\001\000\005\164\001\000\t\236\006\000\t\240\006\000\t\240\007\000\005\228\001\000\005\224\001\000\005\216\001\000\t\240\b\000\t\184\002\000\t\180\002\000\t\180\003\000\t\184\003\000\t\184\004\000\002(\004\000\002(\005\000\b\160\001\000\002(\006\000\001\232\004\000\001\232\005\000\b\160\001\000\001\232\006\000\b\224\001\000\007X\004\000\007T\004\000\007P\004\000\007L\004\000\002\232\001\000\002\184\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002t\001\000\002p\001\000\002l\001\000\002h\001\000\002d\001\000\002`\001\000\002\\\001\000\002X\001\000\007L\005\000\007X\005\000\007X\006\000\005\228\001\000\005\224\001\000\005\216\001\000\007X\007\000\007T\005\000\007P\005\000\007T\006\000\007P\006\000\005\228\001\000\005\224\001\000\005\216\001\000\007P\007\000\007T\007\000\007T\b\000\005\228\001\000\005\224\001\000\005\216\001\000\007T\t\000\006d\005\000\005\176\001\000\005\172\001\000\005\164\001\000\006d\006\000\006`\002\000\006`\003\000\006`\004\000\005\176\001\000\005\172\001\000\005\164\001\000\006`\005\000\004\156\002\000\004\156\003\000\004\156\004\000\004\152\002\000\002\244\003\000\002\244\004\000\005\b\003\000\005\000\003\000\004\248\003\000\005\b\004\000\005\000\004\000\004\248\004\000\005\000\005\000\004\248\005\000\005\000\006\000\004\248\006\000\005\016\001\000\004\248\007\000\005\012\001\000\005\004\001\000\004\252\001\000\000\128\001\000\000l\001\000\005\004\002\000\004\252\002\000\004\252\003\000\000x\002\000\000t\002\000\000t\003\000\0030\003\000\0030\004\000\0030\005\000\b\212\001\000\000\132\002\000\000p\002\000\000\132\003\000\000p\003\000\000\132\004\000\000\132\005\000\000p\004\000\b\212\002\000\b\212\003\000\001\216\001\000\b\216\001\000\001\216\001\000\000X\002\000\000X\003\000\b\216\002\000\b\216\003\000\001\216\001\000\006T\002\000\006T\003\000\006T\004\000\006D\002\000\006,\002\000\001\216\001\000\0064\002\000\012(\002\000\011\176\006\000\011\176\007\000\011\176\b\000\003\\\001\000\002\252\001\000\003\\\002\000\002\252\002\000\002\252\003\000\002\252\004\000\002\252\005\000\011\176\t\000\b`\001\000\b\\\001\000\011\176\n\000\b\\\002\000\b`\002\000\bL\001\000\bT\001\000\bP\001\000\bX\001\000\003`\001\000\003\000\001\000\003\000\002\000\003\000\003\000\003\000\004\000\011\172\004\000\003l\004\000\0050\001\000\003l\005\000\011\172\005\000\011\172\006\000\011\172\007\000\011\172\b\000\b`\001\000\b\\\001\000\011\172\t\000\005\152\003\000\005\152\004\000\005\208\005\000\005\176\001\000\005\172\001\000\005\164\001\000\005\228\001\000\005\224\001\000\005\216\001\000\000\\\005\000\000\\\006\000\012\156\006\000\012\156\007\000\005\200\003\000\005\200\004\000\nt\007\000\005\228\001\000\005\224\001\000\005\216\001\000\nt\b\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\001\016\002\000\001\012\002\000\001\012\003\000\001\016\003\000\001\216\001\000\001\016\004\000\001\016\005\000\t\244\004\000\t\244\005\000\t\244\006\000\002,\004\000\002,\005\000\b\160\001\000\002,\006\000\001\248\004\000\001\244\004\000\001\240\004\000\001\236\004\000\001\248\005\000\001\240\005\000\b\160\001\000\001\248\006\000\001\240\006\000\001\248\007\000\001\248\b\000\001\244\005\000\001\244\006\000\0028\004\000\0028\005\000\0028\006\000\0028\007\000\000\176\003\000\000\176\004\000\001\252\003\000\001\252\004\000\001\252\005\000\001\252\006\000\001\252\007\000\003|\001\000\003|\002\000\000\000\001\000\000\004\000\000\003\136\001\000\003\136\002\000\000\004\001\000\000\b\000\000\012x\001\000\005D\001\000\001\148\001\000\005D\002\000\005D\003\000\005H\001\000\000\b\001\000\005|\001\000\005T\001\000\005P\001\000\005L\001\000\005<\001\000\005T\002\000\005P\002\000\005L\002\000\005<\002\000\012x\001\000\005P\003\000\005P\004\000\005P\005\000\005T\003\000\005L\003\000\000P\001\000\005@\001\000\000T\001\000\007\\\001\000\007\\\002\000\000\012\000\000\000\012\001\000\007`\001\000\007`\002\000\000\016\000\000\000\016\001\000\007d\001\000\001\216\001\000\007d\002\000\000\020\000\000\007h\001\000\007h\002\000\000\020\001\000\000\024\000\000\000\024\001\000\007l\001\000\005|\001\000\005<\001\000\007l\002\000\000\028\000\000\000\028\001\000\007p\001\000\005l\001\000\007p\002\000\000 \000\000\000 \001\000\007t\001\000\005\176\001\000\005\172\001\000\005\164\001\000\007t\002\000\000$\000\000\000$\001\000\007x\001\000\005\228\001\000\005\224\001\000\005\216\001\000\007x\002\000\000(\000\000\000(\001\000\007|\001\000\007|\002\000\000,\000\000\007\168\001\000\007\156\001\000\007\148\001\000\007\140\001\000\007\136\001\000\007\128\001\000\007\128\002\000\000,\001\000\0000\000\000\007\132\001\000\007\132\002\000\0000\001\000\005t\001\000\005l\001\000\005t\002\000\005l\002\000\0004\000\000\011\252\001\000\011\248\001\000\011\244\001\000\011\240\001\000\011\236\001\000\011\232\001\000\011\228\001\000\011\252\002\000\011\248\002\000\011\244\002\000\011\240\002\000\011\236\002\000\011\232\002\000\011\228\002\000\011\252\003\000\011\232\003\000\011\236\003\000\011\248\003\000\011\240\003\000\011\244\003\000\005t\001\000\005l\001\000\012\012\001\000\0004\001\000\012\b\001\000\012\b\002\000\004\184\001\000\004\184\002\000\012\000\001\000\012\000\002\000\012\000\003\000\012\004\001\000\012\004\002\000\0008\000\000\004\196\001\000\004\192\001\000\004\204\001\000\004\200\001\000\004\200\002\000\004\204\002\000\004\196\002\000\004\196\003\000\004\196\004\000\004\192\002\000\0008\001\000\012t\001\000\012t\002\000\012t\003\000\012t\004\000\012p\001\000\012p\002"), (16, "\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\b\000\t\000\n\000\011\000\012\000\r\000\014\000\015\000\016\000\017\000\018\000\019\000\020\000\021\000\022\000\023\000\024\000\025\000\026\000\027\000\028\000\029\000\030\000\031\000 \000!\000\"\000#\000$\000%\000&\000'\000(\000)\000*\000+\000,\000-\000.\000/\0000\0001\0002\0003\0004\0005\0006\0008\0009\000:\000;\000<\000=\000>\000?\000@\000A\000B\000C\000G\000K\000O\000P\000Q\000R\000S\000T\000U\000V\000W\000X\000Y\000[\000\\\000^\000_\000`\000b\000c\000d\000k\000l\000m\000n\000o\000p\000s\000t\000u\000w\000y\000{\000|\000}\000\127\000\128\000\129\000\131\000\132\000\133\000\134\000\135\000\136\000\137\000\138\000\139\000\140\000\141\000\142\000\143\000\144\000\145\000\146\000\147\000\148\000\149\000\150\000\156\000\158\000\159\000\160\000\162\000\164\000\165\000\167\000\169\000\171\000\172\000\174\000\176\000\178\000\179\000\180\000\181\000\182\000\183\000\184\000\185\000\186\000\187\000\188\000\189\000\190\000\191\000\192\000\194\000\195\000\196\000\198\000\199\000\200\000\201\000\202\000\206\000\207\000\208\000\209\000\210\000\211\000\212\000\213\000\214\000\215\000\216\000\217\000\218\000\222\000\226\000\230\000\231\000\233\000\234\000\236\000\238\000\239\000\240\000\241\000\244\000\245\000\246\000\247\000\248\000\249\000\250\000\251\000\252\000\254\000\255\001\000\001\001\001\003\001\005\001\006\001\b\001\012\001\018\001\020\001\021\001\022\001\024\001\028\001\031\001 \001!\001#\001$\001%\001&\001(\001)\001*\001+\0011\0015\0019\001:\001;\001<\001=\001?\001A\001B\001C\001D\001E\001F\001G\001H\001I\001J\001K\001L\001M\001N\001O\001P\001W\001Y\001[\001]\001^\001_\001`\001a\001b\001c\001e\001g\001h\001i\001j\001k\001l\001p\001q\001s\001t\001v\001x\001y\001z\001}\001~\001\129\001\130\001\133\001\134\001\135\001\136\001\137\001\139\001\140\001\141\001\142\001\143\001\144\001\145\001\146\001\148\001\149\001\151\001\152\001\153\001\154\001\157\001\158\001\159\001\160\001\161\001\162\001\163\001\164\001\168\001\169\001\172\001\173\001\174\001\175\001\177\001\178\001\179\001\180\001\182\001\183\001\184\001\185\001\187\001\188\001\189\001\191\001\192\001\193\001\194\001\195\001\197\001\198\001\200\001\201\001\203\001\205\001\206\001\207\001\208\001\210\001\211\001\213\001\214\001\217\001\218\001\219\001\221\001\222\001\223\001\224\001\226\001\230\001\231\001\232\001\233\001\234\001\235\001\236\001\237\001\238\001\239\001\240\001\241\001\242\001\243\001\244\001\245\001\247\001\248\001\249\001\250\001\251\002\002\002\b\002\011\002\012\002\r\002\014\002\015\002\016\002\017\002\019\002\020\002\026\002\027\002!\002\"\002(\002)\002/\0020\0021\0022\0024\002:\002;\002>\002F\002G\002I\002J\002K\002L\002M\002N\002O\002R\002S\002T\002[\002\\\002]\002_\002`\002f\002l\002m\002n\002t\002u\002w\002x\002y\002z\002\130\002\132\002\133\002\134\002\140\002\144\002\147\002\148\002\149\002\150\002\151\002\152\002\153\002\154\002\160\002\162\002\163\002\165\002\166\002\168\002\169\002\170\002\171\002\173\002\174\002\175\002\176\002\177\002\180\002\182\002\183\002\184\002\191\002\192\002\194\002\195\002\196\002\197\002\198\002\199\002\207\002\208\002\209\002\210\002\211\002\212\002\213\002\218\002\220\002\221\002\222\002\223\002\224\002\225\002\227\002\228\002\229\002\230\002\231\002\232\002\233\002\235\002\236\002\237\002\238\002\239\002\243\002\244\002\246\002\248\002\250\002\252\002\253\002\254\003\000\003\001\003\003\003\005\003\006\003\b\003\t\003\011\003\012\003\016\003\018\003\020\003\021\003\025\003\026\003\030\003\031\003\"\003$\003&\003'\003(\003)\003*\003+\003/\0032\0033\0036\0037\0038\003;\003<\003>\003?\003@\003A\003E\003F\003J\003K\003L\003M\003N\003R\003Y\003Z\003_\003`\003a\003e\003f\003g\003h\003j\003k\003o\003p\003r\003t\003w\003x\003y\003{\003|\003}\003~\003\127\003\128\003\130\003\132\003\134\003\136\003\138\003\140\003\141\003\142\003\143\003\144\003\152\003\153\003\155\003\157\003\159\003\167\003\168\003\169\003\170\003\171\003\173\003\175\003\177\003\184\003\185\003\186\003\187\003\188\003\194\003\195\003\196\003\197\003\198\003\211\003\212\003\225\003\226\003\227\003\230\003\231\003\232\003\233\003\234\003\247\003\254\003\255\004\000\004\024\004\026\004\027\004\028\004\029\004\031\004!\004$\004%\004'\004(\004)\004*\004+\004,\004-\004:\004;\004H\004T\004Y\004Z\004\\\004^\004_\004`\004a\004e\004f\004j\004k\004m\004o\004q\004s\004t\004v\004w\004x\004z\004{\004}\004\138\004\139\004\140\004\141\004\142\004\144\004\145\004\146\004\147\004\149\004\150\004\151\004\178\004\179\004\203\004\204\004\228\004\229\004\253\004\254\005\022\005\023\005/\0050\005H\005I\005a\005b\005z\005{\005\147\005\148\005\172\005\173\005\197\005\198\005\222\005\223\005\247\005\248\006\016\006\017\006)\006*\006B\006C\006[\006\\\006t\006u\006\141\006\142\006\166\006\167\006\191\006\192\006\216\006\217\006\219\006\232\006\233\007\001\007\004\007\005\007\006\007\007\007\b\007\t\007\n\007\012\007\r\007\015\007\016\007\017\007\023\007\024\007\025\007\026\007 \007!\007'\007(\007.\007/\0070\0071\0072\0074\0075\007;\007<\007=\007>\007?\007A\007H\007I\007J\007M\007N\007O\007P\007Q\007R\007V\007W\007X\007Y\007Z\007\\\007^\007_\007`\007a\007e\007f\007j\007k\007o\007p\007q\007r\007s\007t\007u\007v\007w\007x\007y\007z\007{\007|\007}\007~\007\127\007\128\007\129\007\130\007\131\007\132\007\136\007\137\007\138\007\139\007\140\007\141\007\142\007\144\007\145\007\146\007\147\007\149\007\150\007\151\007\153\007\154\007\155\007\156\007\158\007\160\007\162\007\164\007\165\007\167\007\168\007\169\007\170\007\172\007\173\007\174\007\175\007\177\007\179\007\181\007\183\007\184\007\186\007\188\007\190\007\191\007\192\007\194\007\195\007\196\007\198\007\199\007\200\007\202\007\204\007\208\007\209\007\213\007\214\007\216\007\219\007\221\007\222\007\223\007\224\007\225\007\229\007\232\007\234\007\235\007\236\007\239\007\244\007\245\007\246\007\249\007\254\007\255\b\000\b\001\b\002\b\004\b\n\b\016\b\022\b\025\b\028\b\031\b \b$\b%\b&\b'\b(\b*\b+\b,\b-\b/\b0\b1\b2\b4\b5\b6\b7\b?\bE\bH\bI\bJ\bK\bL\bM\bN\bO\bP\bQ\bR\bS\bT\bU\bV\bW\bY\bZ\b[\b\\\b]\b^\b`\ba\bb\bc\bd\bg\bj\bk\bl\bn\bo\bp\br\bs\bt\bu\bv\bx\by\bz\b|\b}\b~\b\127\b\130\b\131\b\132\b\133\b\136\b\137\b\143\b\145\b\147\b\149\b\151\b\152\b\156\b\157\b\161\b\165\b\167\b\168\b\171\b\172\b\173\b\174\b\175\b\179\b\180\b\181\b\182\b\183\b\184\b\188\b\189\b\190\b\191\b\193\b\194\b\196\b\197\b\198\b\202\b\203\b\204\b\205\b\206\b\207\b\208\b\209\b\213\b\214\b\215\b\216\b\217\b\218\b\220\b\221\b\222\b\223\b\224\b\225\b\226\b\228\b\229\b\230\b\231\b\232\b\233\b\234\b\235\b\237\b\238\b\239\b\240\b\241\b\243\b\244\b\246\b\247\b\248\b\249\b\250\b\252\b\253\b\254\b\255\t\001\t\002\t\004\t\005\t\006\t\007\t\b\t\t\t\n\t\011\t\012\t\014\t\016\t\017\t\018\t\020\t\021\t\022\t\024\t\025\t\026\t\027\t\029\t\031\t \t!\t#\t$\t%\t'\t(\t*\t,\t-\t.\t/\t1\t2\t4\t5\t6\t7\t8\t9\t:\t;\t<\t=\t?\t@\tA\tB\tC\tD\tE\tF\tH\tI\tJ\tK\tL\tM\tN\tO\tP\tQ\tS\tT\tU\tV\tZ\t]\t^\t_\t`\ta\tb\td\tf\tg\ti\tj\tk\tl\tm\tn\to\tp\tq\tr\ts\tt\tu\tv\tw\tx\ty\tz\t{\t|\t}\t~\t\127\t\128\t\129\t\130\t\131\t\132\t\133\t\134\t\135\t\136\t\138\t\139\t\140\t\141\t\142\t\143\t\144\t\145\t\146\t\147\t\148\t\150\t\151\t\152\t\153\t\154\t\155\t\156\t\157\t\158\t\160\t\162\t\163\t\164\t\165\t\166\t\167\t\168\t\169\t\170\t\171\t\172\t\174\t\176\t\178\t\180\t\181\t\182\t\183\t\184\t\185\t\186\t\187\t\190\t\192\t\193\t\195\t\196\t\197\t\198\t\199\t\201\t\203\t\205\t\206\t\207\t\208\t\209\t\210\t\211\t\214\t\217\t\220\t\223\t\225\t\226\t\227\t\228\t\230\t\231\t\232\t\233\t\234\t\235\t\236\t\237\t\238\t\239\t\240\t\241\t\242\t\243\t\244\t\245\t\249\t\251\t\252\t\254\t\255\n\000\n\001\n\002\n\003\n\006\n\t\n\011\n\012\n\r\n\014\n\016\n\017\n\018\n\019\n\020\n\021\n\022\n\023\n\024\n\025\n\026\n\028\n\029\n\030\n \n$\n%\n&\n'\n(\n)\n*\n,\n-\n.\n0\n1\n2\n4\n5\n6\n7\n8\n:\n;\n=\n>\n?\nA\nB\nO\n\\\n^\n_\n`\na\nc\nd\ne\ng\nh\ni\nk\nl\nn\no\nq\nr\ns\nt\nu\nx\ny\nz\n{\n|\n~\n\127\n\128\n\129\n\130\n\131\n\133\n\134\n\135\n\136\n\137\n\138\n\139\n\140\n\141\n\142\n\143\n\144\n\145\n\146\n\148\n\149\n\150\n\151\n\153\n\154\n\155\n\156\n\157\n\158\n\159\n\160\n\161\n\162\n\163\n\164\n\165\n\166\n\167\n\168\n\169\n\170\n\171\n\172\n\173\n\174\n\175\n\176\n\177\n\178\n\179\n\181\n\182\n\183\n\185\n\186\n\187\n\188\n\189\n\190\n\191\n\192\n\193\n\194\n\195\n\196\n\197\n\198\n\201\n\202\n\205\n\206\n\207\n\208\n\209\n\210\n\234\n\240\n\241\n\242\n\244\n\245\n\246\n\247\n\248\n\249\n\251\n\252\n\253\n\255\011\000\011\001\011\002\011\028\011\030\011\031\011!\011\"\011#\011$\011%\011&\011'\011(\0115\0116\0117\011:\011;\011>\011A\011C\011D\011E\011F\011G\011U\011b\011d\011e\011k\011m\011o\011q\011r\011\138\011\140\011\142\011\144\011\145\011\169\011\171\011\173\011\175\011\176\011\200\011\214\011\216\011\218\011\220\011\221\011\245\011\247\011\249\011\251\011\252\012\020\012\022\012\024\012\026\012\027\0123\012;\012A\012C\012E\012G\012H\012`\012b\012d\012f\012g\012\127\012\129\012\131\012\133\012\134\012\158\012\160\012\161\012\185\012\187\012\211\012\212\012\213\012\214\012\215\012\216\012\217\012\218\012\219\012\224\012\227\012\228\012\229\012\230\012\231\012\232\012\233\012\234\012\235\012\236\012\237\012\238\012\239\012\240\012\241\012\242\012\243\012\244\012\245\012\246\012\247\012\248\012\249\012\250\012\251\012\252\012\253\012\254\012\255\r\000\r\001\r\002\r\003\r\004\r\005\r\006\r\007\r\b\r\t\r\017\r\018\r\019\r\020\r\021\r\024\r\025\r\026\r\027\r\028\r\029\r\030\r\031\r \r!\r\"\r#\r%\r&\r'\r(\r*\r+\r,\r-\r/\r1\rJ\rK\rc\rd\re\rf\rs\r\139\r\140\r\153\r\154\r\155\r\179\r\182\r\184\r\185\r\186\r\187\r\188\r\189\r\190\r\191\r\192\r\193\r\197\r\198\r\199\r\200\r\201\r\202\r\203\r\204\r\205\r\206\r\207\r\208\r\209\r\210\r\211\r\212\r\213\r\214\r\215\r\216\r\217\r\218\r\219\r\220\r\221\r\225\r\226\r\227\r\228\r\230\r\231\r\232\r\234\r\235\r\237\r\238\r\239\r\240\r\241\r\242\r\243\r\244\r\245\014\r\014\014\014\015\014\016\014\029\014\031\014!\014#\014(\014)\014*\014.\014/\0141\0142\0143\0144\0145\0146\0148\0149\014:\014<\014W\014X\014Y\014]\014^\014`\014e\014f\014g\014k\014l\014p\014q\014r\014s\014w\014x\014y\014z\014{\014|\014}\014~\014\129\014\132\014\134\014\136\014\137\014\138\014\143\014\145\014\146\014\147\014\148\014\149\014\150\014\151\014\152\014\155\014\157\014\158\014\159\014\160\014\161\014\163\014\166\014\167\014\168\014\170\014\171\014\172\014\173\014\174\014\176\014\177\014\178\014\179\014\180\014\181\014\183\014\185\014\186\014\187\014\188\014\191\014\192\014\193\014\194\014\195\014\196\014\197\014\198\014\200\014\201\014\202\014\203\014\205\014\207\014\208\014\209\014\210\014\213\014\214\014\215\014\216\014\220\014\224\014\225\014\226\014\227\014\228\014\229\014\233\014\234\014\241\014\242\014\243\014\245\014\246\014\247\014\248\014\249\014\250\014\251\014\253\015\001\015\003\015\006\015\007\015\b\015\t\015\n\015\011\015\012\015\r\015\014\015\015\015\016\015\017\015\018\015\019\015\020\015\021\015\022\015\023\015\024\015\025\015\026\015\027\015\028\015\029\015 \015!\015\"\015#\015$\015)\015-\015/\0150\0151\0152\0153\0154\0155\0156\0157\0158\0159\015:\015;\015<\015=\015>\015@\015A\015B\015C\015D\015E\015F\015G\015J\015K\015L\015M\015O\015P\015Q\015R\015V\015W\015X\015Y\015]\015^\015_\015`\015a\015b\015c\015i\015j\015k\015l\015m\015n\015o\015q\015s\015t\015{\015\130\015\131\015\132\015\133\015\134\015\135\015\138\015\139\015\140\015\141\015\142\015\143\015\144\015\145\015\146\015\147\015\148\015\149\015\150\015\152\015\153\015\154\015\155\015\156\015\157\015\158\015\159\015\160\015\161\015\162\015\163\015\164\015\165\015\166\015\167")) + ((32, "\000\000\000\000\000\002X\001\000\001\244\001\000\0124\001\000\0120\001\000\012,\001\000\012(\001\000\012$\001\000\011p\001\000\012 \001\000\012\028\001\000\012\024\001\000\012\020\001\000\012\016\001\000\012\012\001\000\012\b\001\000\012\004\001\000\012\000\001\000\011\252\001\000\011\248\001\000\011\244\001\000\011\240\001\000\011\236\001\000\011\232\001\000\011\228\001\000\011\224\001\000\011\220\001\000\011\216\001\000\011l\001\000\011\212\001\000\011\208\001\000\011\204\001\000\011\200\001\000\011\196\001\000\011\192\001\000\011\188\001\000\011\184\001\000\011\180\001\000\011\176\001\000\011\172\001\000\011\168\001\000\011\164\001\000\011\160\001\000\011\156\001\000\011\152\001\000\011\148\001\000\011\144\001\000\011\140\001\000\011\136\001\000\011\132\001\000\011\128\001\000\011|\001\000\011x\001\000\011t\001\000\000\132\001\000\000\128\001\000\000\132\002\000\000\132\003\000\001\244\002\000\002X\002\000\000\140\001\000\000\140\002\000\rX\001\000\rX\002\000\rX\003\000\r4\001\000\007L\001\000\006\248\001\000\007@\001\000\007<\001\000\0078\001\000\007P\001\000\007`\001\000\007H\001\000\007D\001\000\006\252\001\000\007X\001\000\0074\001\000\0070\001\000\007,\001\000\007(\001\000\007$\001\000\007\028\001\000\007\\\001\000\007T\001\000\007\024\001\000\007\020\001\000\007\016\001\000\007\012\001\000\007\b\001\000\007\004\001\000\007\b\002\000\007\004\002\000\004\012\001\000\004\012\002\000\007\b\003\000\007\004\003\000\007\b\004\000\007\004\004\000\007\b\005\000\007\016\002\000\007\012\002\000\007\016\003\000\007\012\003\000\007\016\004\000\007\012\004\000\007\016\005\000\007\024\002\000\007\020\002\000\007\024\003\000\007\020\003\000\007\024\004\000\007\020\004\000\007\024\005\000\007p\001\000\007d\001\000\007 \001\000\007\000\001\000\007h\001\000\007l\001\000\r4\002\000\r4\003\000\r8\001\000\rX\004\000\rX\005\000\000|\001\000\005\180\001\000\001\252\001\000\t<\001\000\000x\001\000\003\252\001\000\004\000\001\000\t<\002\000\000x\002\000\007\212\001\000\007\212\002\000\007\212\003\000\007\208\001\000\001\200\001\000\001\196\001\000\000p\001\000\000d\001\000\000x\001\000\000x\002\000\001\200\002\000\001\200\003\000\001\200\004\000\005\180\001\000\003\252\001\000\006D\001\000\006D\002\000\n\024\001\000\n\020\001\000\003\248\001\000\003\244\001\000\003\240\001\000\003\236\001\000\n\024\002\000\n\020\002\000\003\248\002\000\003\244\002\000\003\240\002\000\003\236\002\000\n\024\003\000\n\020\003\000\003\248\003\000\003\244\003\000\003\240\003\000\003\236\003\000\r(\001\000\r\020\001\000\r\b\001\000\r\020\002\000\n\024\004\000\003\248\004\000\003\240\004\000\r\028\001\000\r\012\001\000\r\028\002\000\012\248\001\000\r$\001\000\r \001\000\r\024\001\000\r\016\001\000\r\024\002\000\r \002\000\012\236\001\000\r\000\001\000\012\252\001\000\012\252\002\000\012\236\002\000\tp\001\000\012\248\002\000\tt\001\000\012\248\003\000\tt\002\000\tt\003\000\n\024\005\000\003\248\005\000\003\240\005\000\005\172\001\000\003\248\006\000\003\240\006\000\012\228\001\000\005\180\001\000\001|\001\000\001x\001\000\006\212\001\000\006\196\001\000\006\180\001\000\006\172\001\000\001\200\001\000\001\196\001\000\001\128\001\000\001p\001\000\000p\001\000\000d\001\000\001p\002\000\005\172\001\000\003\184\001\000\003\184\002\000\005\172\001\000\006\228\001\000\006\224\001\000\005\172\001\000\005\132\001\000\005|\001\000\005t\001\000\005\132\002\000\005|\002\000\005t\002\000\001\248\001\000\001\248\002\000\n\244\001\000\005\228\001\000\012l\001\000\012h\001\000\003\248\001\000\003\244\001\000\012l\002\000\012h\002\000\003\248\002\000\003\244\002\000\012l\003\000\012h\003\000\003\248\003\000\003\244\003\000\012l\004\000\003\248\004\000\012l\005\000\003\248\005\000\005\172\001\000\003\248\006\000\003\248\007\000\t\024\001\000\003\248\b\000\b\176\001\000\b\176\002\000\002<\001\000\002<\002\000\002<\003\000\001d\001\000\n\204\001\000\n\184\001\000\n\184\002\000\n\184\003\000\000\236\001\000\000\232\001\000\011<\001\000\nX\001\000\nT\001\000\nT\002\000\nX\002\000\nP\001\000\nL\001\000\nL\002\000\nP\002\000\r4\001\000\011d\001\000\0118\001\000\0114\001\000\011,\001\000\001\144\001\000\001p\001\000\nX\001\000\nT\001\000\0078\001\000\0118\002\000\0114\002\000\0118\003\000\0114\003\000\0118\004\000\0114\004\000\006<\001\000\0068\001\000\0118\005\000\0114\005\000\0114\006\000\0118\006\000\006L\001\000\006L\002\000\006L\003\000\006L\004\000\0064\001\000\006\020\001\000\006\020\002\000\005$\001\000\005 \001\000\004\024\001\000\000@\001\000\000<\001\000\006\236\001\000\006\232\001\000\006\236\002\000\006\236\003\000\006\236\004\000\007\252\001\000\007\248\001\000\007\244\001\000\007\240\001\000\007\236\001\000\007\232\001\000\007\228\001\000\007\224\001\000\007\220\001\000\007\216\001\000\007\252\002\000\007\248\002\000\007\244\002\000\007\240\002\000\007\236\002\000\007\232\002\000\007\228\002\000\007\224\002\000\007\252\003\000\007\248\003\000\007\244\003\000\007\240\003\000\007\236\003\000\007\232\003\000\007\228\003\000\007\224\003\000\n\172\001\000\n\172\002\000\n\172\003\000\005\220\001\000\005\232\001\000\005\224\001\000\005\232\002\000\005\224\002\000\005\232\003\000\005\224\003\000\005\252\001\000\000\228\001\000\n\172\004\000\004\244\001\000\004\244\002\000\012\148\001\000\012\144\001\000\0028\001\000\0028\002\000\0028\003\000\r4\001\000\n\180\001\000\n\176\001\000\n|\001\000\nx\001\000\001\144\001\000\001p\001\000\n\204\001\000\006\248\001\000\011\b\001\000\011\004\001\000\r8\001\000\003<\001\000\0038\001\000\003<\002\000\0038\002\000\003,\001\000\nh\001\000\nd\001\000\n`\001\000\001l\001\000\001l\002\000\n\\\001\000\0048\001\000\n\\\002\000\n\\\003\000\005d\001\000\005`\001\000\005\\\001\000\005X\001\000\007\160\001\000\001\228\001\000\001\224\001\000\007\128\001\000\001\228\002\000\001\224\002\000\001\220\001\000\001\216\001\000\001\220\002\000\001\216\002\000\001\212\001\000\001\208\001\000\001\204\001\000\000h\001\000\005\248\001\000\005\184\001\000\005\176\001\000\005\248\002\000\005\248\003\000\005\248\001\000\005\184\001\000\005\248\004\000\005\184\002\000\005\184\003\000\005\244\001\000\005\184\002\000\005\176\002\000\005\176\003\000\001X\001\000\000h\002\000\001\208\002\000\006\148\001\000\006\148\002\000\000\\\001\000\003\188\001\000\003\176\001\000\003\188\002\000\012\208\001\000\t\160\001\000\t\160\002\000\001\184\001\000\005\248\001\000\005\184\001\000\005\176\001\000\000t\001\000\005\184\002\000\005\176\002\000\000t\002\000\001\200\001\000\001\196\001\000\003\180\001\000\003\180\002\000\003\180\003\000\012\232\001\000\003\180\004\000\001\188\001\000\002\b\001\000\001\192\001\000\000X\001\000\012\204\001\000\t\164\001\000\000l\001\000\000`\001\000\t\164\002\000\t\164\003\000\000l\001\000\000`\001\000\000l\002\000\000l\003\000\000`\002\000\000D\001\000\001\196\002\000\001\180\001\000\001\196\003\000\001\180\002\000\001\176\001\000\000H\001\000\000H\002\000\000H\003\000\000H\004\000\000t\003\000\t\160\003\000\000l\001\000\000`\001\000\003\188\003\000\t\168\001\000\t`\001\000\td\001\000\001\208\003\000\001\208\004\000\td\002\000\td\003\000\012\156\001\000\012\152\001\000\012\152\002\000\007t\001\000\012\152\003\000\012\152\004\000\tT\001\000\tT\002\000\tT\003\000\000H\001\000\012\152\005\000\tP\001\000\000H\001\000\012\156\002\000\t\172\001\000\001\180\001\000\t\168\001\000\001\204\002\000\001\204\003\000\001\212\002\000\001\212\003\000\td\001\000\001\212\004\000\001\212\005\000\td\001\000\001\216\003\000\001\216\004\000\td\001\000\001\228\003\000\001\224\003\000\001\224\004\000\001\228\004\000\t8\001\000\001\228\005\000\001\228\006\000\t8\002\000\t4\001\000\007\160\002\000\001\180\001\000\005d\002\000\005`\002\000\005\\\002\000\005X\002\000\007\188\001\000\bh\001\000\bh\002\000\bh\003\000\001\\\001\000\011P\001\000\011P\002\000\001h\001\000\001t\001\000\001`\001\000\011$\001\000\r<\001\000\011(\001\000\bh\004\000\0110\001\000\011D\001\000\011@\001\000\011D\002\000\011D\003\000\nH\001\000\011L\001\000\011`\001\000\011\\\001\000\011X\001\000\011T\001\000\005\232\001\000\001\140\001\000\001\136\001\000\011`\002\000\011\\\002\000\011X\002\000\011T\002\000\005\232\002\000\001\140\002\000\011`\003\000\011\\\003\000\001\140\003\000\011\\\004\000\bD\001\000\bD\002\000\bD\003\000\bX\001\000\b4\001\000\bH\001\000\b<\001\000\bH\002\000\bL\001\000\bH\003\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\bL\002\000\bL\003\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\b,\002\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\003\000\b,\001\000\b@\002\000\bL\001\000\b@\003\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\b8\002\000\b8\003\000\b0\002\000\011L\001\000\bd\001\000\bd\002\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\011h\001\000\011H\001\000\b`\001\000\b\\\001\000\r4\001\000\011d\001\000\0118\001\000\0114\001\000\011,\001\000\b`\002\000\001\144\001\000\001p\001\000\b`\003\000\006\156\001\000\006\152\001\000\006\156\002\000\b`\004\000\b`\005\000\b`\006\000\011H\001\000\001\148\001\000\nP\001\000\nL\001\000\007D\001\000\001\144\002\000\001\144\003\000\011d\002\000\011,\002\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\011,\003\000\011d\003\000\011d\004\000\001\180\001\000\011d\005\000\b\\\002\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\bL\001\000\bD\004\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\001\140\004\000\001\140\005\000\011`\004\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\011`\005\000\011X\003\000\n`\001\000\011X\004\000\n`\002\000\n`\003\000\t\220\001\000\t\216\001\000\t\212\001\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\t\220\002\000\t\216\002\000\t\220\003\000\011T\003\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\007\188\002\000\005d\003\000\005`\003\000\005\\\003\000\005X\003\000\005d\004\000\005`\004\000\005\\\004\000\005`\005\000\007\136\001\000\005`\006\000\005d\005\000\nh\002\000\nd\002\000\nd\003\000\011$\001\000\004\180\001\000\004\176\001\000\004h\001\000\004d\001\000\004d\002\000\0044\001\000\0040\001\000\0044\002\000\0044\003\000\001\180\001\000\004d\003\000\004d\004\000\004h\002\000\004X\001\000\004T\001\000\004T\002\000\004T\003\000\007\196\001\000\004\148\001\000\0020\001\000\002,\001\000\002(\001\000\002$\001\000\0020\002\000\002,\002\000\0020\003\000\0020\004\000\0020\005\000\006\024\001\000\006\024\002\000\003\196\001\000\003\192\001\000\003\192\002\000\003\196\002\000\003\196\003\000\006\\\001\000\006P\001\000\006\\\002\000\006\\\003\000\006H\001\000\006H\002\000\t(\001\000\003\200\001\000\t(\002\000\006H\003\000\006H\004\000\006X\001\000\006d\001\000\006`\001\000\006T\001\000\006H\005\000\006d\002\000\r\128\001\000\r|\001\000\r\128\002\000\r|\002\000\r\128\003\000\r|\003\000\r\152\001\000\r\148\001\000\r\152\002\000\r\128\004\000\r\128\005\000\000H\001\000\r|\004\000\r|\005\000\000H\001\000\r|\006\000\t\024\001\000\t\024\002\000\t\024\003\000\001\180\001\000\t\024\004\000\t\024\005\000\001\180\001\000\012\244\001\000\r\144\001\000\r\140\001\000\r\136\001\000\r\132\001\000\r\144\002\000\r\140\002\000\r\144\003\000\r\140\003\000\r\140\004\000\r\140\005\000\006d\001\000\006`\001\000\006T\001\000\006`\002\000\006d\001\000\006`\003\000\006`\001\000\006T\001\000\006T\002\000\005\248\001\000\005\216\001\000\005\184\001\000\005\216\002\000\005\184\002\000\005\184\003\000\003\252\001\000\005\216\003\000\006t\001\000\005\212\001\000\006h\001\000\r\144\004\000\r\144\005\000\006d\001\000\006`\001\000\006T\001\000\r\136\002\000\r\132\002\000\005\232\001\000\r\132\003\000\r\132\004\000\005\248\001\000\005\184\001\000\005\232\002\000\r\136\003\000\r\136\004\000\005\248\001\000\005\184\001\000\tX\001\000\t\\\001\000\006d\003\000\t\\\002\000\t\\\003\000\t$\001\000\006d\001\000\006`\001\000\006\\\004\000\006T\001\000\006d\001\000\006`\001\000\006T\001\000\006P\002\000\006P\003\000\006d\001\000\006`\001\000\006T\001\000\003\196\004\000\003\196\005\000\006\024\003\000\006\024\004\000\006\028\001\000\006,\001\000\006(\001\000\006 \001\000\006\024\005\000\007\252\001\000\007\248\001\000\007\244\001\000\007\240\001\000\007\236\001\000\007\232\001\000\007\228\001\000\007\224\001\000\007\220\001\000\007\216\001\000\006,\002\000\006,\003\000\007\220\002\000\007\216\002\000\006,\001\000\006(\001\000\006 \001\000\007\220\003\000\007\216\003\000\007\216\004\000\006d\001\000\006`\001\000\006T\001\000\007\216\005\000\006(\002\000\006 \002\000\006$\001\000\005\232\001\000\0060\001\000\006,\001\000\006(\001\000\006 \001\000\0020\006\000\0020\007\000\011\020\001\000\001l\001\000\n\216\001\000\n\212\001\000\t\208\001\000\t\204\001\000\t\200\001\000\007\172\001\000\007\168\001\000\n\252\001\000\r8\001\000\005\220\001\000\nt\001\000\np\001\000\nl\001\000\002d\001\000\002d\002\000\002d\003\000\n\168\001\000\n\164\001\000\n\168\002\000\n\164\002\000\n\168\003\000\n\164\003\000\002T\001\000\002P\001\000\002L\001\000\002H\001\000\002D\001\000\002@\001\000\002T\002\000\002P\002\000\002L\002\000\002H\002\000\002D\002\000\002@\002\000\002T\003\000\002P\003\000\002L\003\000\002H\003\000\002D\003\000\002@\003\000\t\240\001\000\t\156\001\000\t\152\001\000\t\240\002\000\t\156\002\000\t\152\002\000\t\240\003\000\t\156\003\000\t\152\003\000\tH\001\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\005p\001\000\005l\001\000\005h\001\000\005l\002\000\0024\001\000\0024\002\000\0024\003\000\004`\001\000\004\\\001\000\b\136\001\000\004\\\002\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\004\172\001\000\004\168\001\000\004\172\002\000\004\172\003\000\001\180\001\000\004\\\003\000\004\\\004\000\004\\\005\000\b\132\001\000\004`\002\000\r4\001\000\011d\001\000\0118\001\000\0114\001\000\011,\001\000\003\148\001\000\001\144\001\000\001p\001\000\003\148\002\000\003\148\003\000\003\148\004\000\004l\001\000\004l\002\000\004p\001\000\t \001\000\003\156\001\000\003\152\001\000\t \002\000\0024\004\000\007\152\001\000\007\152\002\000\000l\001\000\000`\001\000\0024\005\000\0024\006\000\t\156\001\000\t\152\001\000\002\024\001\000\t\156\002\000\t\152\002\000\002\024\002\000\t\156\003\000\t\152\003\000\002\024\003\000\t\156\004\000\t\152\004\000\tL\001\000\002\024\004\000\t\156\005\000\t\152\005\000\t\156\006\000\t\156\001\000\t\152\001\000\t\156\007\000\t\156\002\000\t\152\002\000\t\156\b\000\t\156\003\000\t\152\003\000\t\156\t\000\t\156\004\000\t\152\004\000\tL\001\000\tL\002\000\tL\003\000\tD\001\000\002\\\001\000\002\\\002\000\002\\\003\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\002\\\004\000\002\\\005\000\n\208\001\000\n\188\001\000\005\236\001\000\n\236\001\000\n\232\001\000\n\220\001\000\n\208\002\000\n\160\001\000\n\156\001\000\n\152\001\000\n\148\001\000\n\144\001\000\n\140\001\000\n\136\001\000\n\132\001\000\n\128\001\000\n\236\002\000\n\236\003\000\n\236\001\000\n\232\001\000\n\220\001\000\n\160\001\000\n\156\001\000\n\152\001\000\n\148\001\000\n\144\001\000\n\140\001\000\n\136\001\000\n\132\001\000\n\128\001\000\n\232\002\000\n\232\003\000\n\156\002\000\n\148\002\000\n\140\002\000\n\140\003\000\t\196\001\000\t\188\001\000\t\184\001\000\t\156\001\000\t\152\001\000\t\196\002\000\t\188\002\000\t\184\002\000\t\156\002\000\t\152\002\000\t\196\003\000\t\188\003\000\t\184\003\000\t\156\003\000\t\152\003\000\t\196\004\000\t\188\004\000\t\184\004\000\t\156\004\000\t\152\004\000\tL\001\000\t\196\005\000\t\188\005\000\002`\001\000\002`\002\000\002`\003\000\n\236\001\000\n\232\001\000\n\220\001\000\n\160\001\000\n\156\001\000\n\152\001\000\n\148\001\000\n\144\001\000\n\140\001\000\n\136\001\000\n\132\001\000\n\128\001\000\002`\004\000\n\220\002\000\n\160\002\000\n\152\002\000\n\144\002\000\n\136\002\000\n\132\002\000\n\128\002\000\n\128\003\000\003\028\001\000\003\024\001\000\t\156\001\000\t\152\001\000\003\028\002\000\t\156\002\000\t\152\002\000\003\028\003\000\t\156\003\000\t\152\003\000\003\028\004\000\t\156\004\000\t\152\004\000\tL\001\000\003\028\005\000\n\236\001\000\n\232\001\000\n\220\001\000\n\160\001\000\n\156\001\000\n\152\001\000\n\148\001\000\n\144\001\000\n\140\001\000\n\136\001\000\n\132\001\000\n\128\001\000\003\140\001\000\003\136\001\000\003\132\001\000\003\128\001\000\003|\001\000\003x\001\000\003t\001\000\003p\001\000\003l\001\000\003h\001\000\003d\001\000\003`\001\000\003\\\001\000\003X\001\000\003T\001\000\003P\001\000\003L\001\000\003H\001\000\003D\001\000\003@\001\000\002h\001\000\002 \001\000\004H\001\000\004D\001\000\004H\002\000\004H\003\000\012\220\001\000\012\220\002\000\001\180\001\000\012\216\001\000\012\212\001\000\012\216\002\000\012\212\002\000\001\180\001\000\012\216\003\000\012\216\004\000\001\180\001\000\004H\004\000\004H\005\000\004D\002\000\004L\001\000\004L\002\000\004P\001\000\n\236\001\000\n\232\001\000\n\220\001\000\n\160\001\000\n\156\001\000\n\152\001\000\n\148\001\000\n\144\001\000\n\140\001\000\n\136\001\000\n\132\001\000\n\128\001\000\004P\002\000\n\200\001\000\011 \001\000\011\028\001\000\011\024\001\000\011\016\001\000\011\012\001\000\011\000\001\000\n\248\001\000\n\228\001\000\n\224\001\000\005\240\001\000\005\232\001\000\001\140\001\000\001\136\001\000\011 \002\000\011\028\002\000\011\024\002\000\011\016\002\000\011\012\002\000\011\000\002\000\n\248\002\000\n\228\002\000\n\224\002\000\005\240\002\000\005\232\002\000\001\140\002\000\r4\001\000\011 \003\000\n\248\003\000\n\224\003\000\001\140\003\000\n\248\004\000\007<\001\000\000@\001\000\0078\001\000\000<\001\000\011 \004\000\011 \005\000\011 \006\000\011 \007\000\006,\001\000\006(\001\000\006 \001\000\011 \b\000\011 \t\000\006d\001\000\006`\001\000\006T\001\000\011 \n\000\012\148\001\000\007H\001\000\012\144\001\000\007D\001\000\006\252\001\000\003,\001\000\bX\001\000\004\184\001\000\004\184\002\000\004\184\003\000\001\180\001\000\004\184\004\000\004\184\005\000\t\140\001\000\t\136\001\000\002l\001\000\t\140\002\000\t\136\002\000\t\156\001\000\t\152\001\000\t\140\003\000\t\156\002\000\t\152\002\000\t\140\004\000\t\156\003\000\t\152\003\000\t\140\005\000\t\156\004\000\t\152\004\000\t\140\006\000\tL\001\000\n\200\001\000\002t\001\000\n\236\001\000\n\232\001\000\n\220\001\000\n\160\001\000\n\156\001\000\n\152\001\000\n\148\001\000\n\144\001\000\n\140\001\000\n\136\001\000\n\132\001\000\n\128\001\000\002t\002\000\r@\001\000\n\240\001\000\n\196\001\000\n\192\001\000\004\152\001\000\003(\001\000\003(\002\000\003(\003\000\t\236\001\000\t\148\001\000\t\144\001\000\003\172\001\000\003\168\001\000\003\164\001\000\003\160\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002\204\002\000\002\200\002\000\t\156\001\000\t\152\001\000\002\204\003\000\t\156\002\000\t\152\002\000\002\204\004\000\t\156\003\000\t\152\003\000\002\204\005\000\t\156\004\000\t\152\004\000\tL\001\000\002\204\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\003\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002\180\002\000\002\176\002\000\t\156\001\000\t\152\001\000\002\180\003\000\t\156\002\000\t\152\002\000\002\180\004\000\t\156\003\000\t\152\003\000\002\180\005\000\t\156\004\000\t\152\004\000\tL\001\000\002\180\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\003\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002\172\002\000\002\168\002\000\t\156\001\000\t\152\001\000\002\172\003\000\t\156\002\000\t\152\002\000\002\172\004\000\t\156\003\000\t\152\003\000\002\172\005\000\t\156\004\000\t\152\004\000\tL\001\000\002\172\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\003\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002\164\002\000\002\160\002\000\t\156\001\000\t\152\001\000\002\164\003\000\t\156\002\000\t\152\002\000\002\164\004\000\t\156\003\000\t\152\003\000\002\164\005\000\t\156\004\000\t\152\004\000\tL\001\000\002\164\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\003\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002\212\002\000\002\208\002\000\t\156\001\000\t\152\001\000\002\212\003\000\t\156\002\000\t\152\002\000\002\212\004\000\t\156\003\000\t\152\003\000\002\212\005\000\t\156\004\000\t\152\004\000\tL\001\000\002\212\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\003\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002\244\002\000\002\240\002\000\t\156\001\000\t\152\001\000\002\244\003\000\t\156\002\000\t\152\002\000\002\244\004\000\t\156\003\000\t\152\003\000\002\244\005\000\t\156\004\000\t\152\004\000\tL\001\000\002\244\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\003\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002\196\002\000\002\192\002\000\t\156\001\000\t\152\001\000\002\196\003\000\t\156\002\000\t\152\002\000\002\196\004\000\t\156\003\000\t\152\003\000\002\196\005\000\t\156\004\000\t\152\004\000\tL\001\000\002\196\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\003\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002\188\002\000\002\184\002\000\t\156\001\000\t\152\001\000\002\188\003\000\t\156\002\000\t\152\002\000\002\188\004\000\t\156\003\000\t\152\003\000\002\188\005\000\t\156\004\000\t\152\004\000\tL\001\000\002\188\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\003\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002\228\002\000\002\224\002\000\t\156\001\000\t\152\001\000\002\228\003\000\t\156\002\000\t\152\002\000\002\228\004\000\t\156\003\000\t\152\003\000\002\228\005\000\t\156\004\000\t\152\004\000\tL\001\000\002\228\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\003\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002\156\002\000\002\152\002\000\t\156\001\000\t\152\001\000\002\156\003\000\t\156\002\000\t\152\002\000\002\156\004\000\t\156\003\000\t\152\003\000\002\156\005\000\t\156\004\000\t\152\004\000\tL\001\000\002\156\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\003\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002\148\002\000\002\144\002\000\t\156\001\000\t\152\001\000\002\148\003\000\t\156\002\000\t\152\002\000\002\148\004\000\t\156\003\000\t\152\003\000\002\148\005\000\t\156\004\000\t\152\004\000\tL\001\000\002\148\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\003\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002\140\002\000\002\136\002\000\t\156\001\000\t\152\001\000\002\140\003\000\t\156\002\000\t\152\002\000\002\140\004\000\t\156\003\000\t\152\003\000\002\140\005\000\t\156\004\000\t\152\004\000\tL\001\000\002\140\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\003\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002\132\002\000\002\128\002\000\t\156\001\000\t\152\001\000\002\132\003\000\t\156\002\000\t\152\002\000\002\132\004\000\t\156\003\000\t\152\003\000\002\132\005\000\t\156\004\000\t\152\004\000\tL\001\000\002\132\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\003\000\002\128\001\000\002|\001\000\002x\001\000\002|\002\000\002x\002\000\t\156\001\000\t\152\001\000\002|\003\000\t\156\002\000\t\152\002\000\002|\004\000\t\156\003\000\t\152\003\000\002|\005\000\t\156\004\000\t\152\004\000\tL\001\000\002|\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\003\000\002x\001\000\002\236\002\000\002\232\002\000\t\156\001\000\t\152\001\000\002\236\003\000\t\156\002\000\t\152\002\000\002\236\004\000\t\156\003\000\t\152\003\000\002\236\005\000\t\156\004\000\t\152\004\000\tL\001\000\002\236\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\003\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002\220\002\000\002\216\002\000\t\156\001\000\t\152\001\000\002\220\003\000\t\156\002\000\t\152\002\000\002\220\004\000\t\156\003\000\t\152\003\000\002\220\005\000\t\156\004\000\t\152\004\000\tL\001\000\002\220\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\003\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\t\148\002\000\t\144\002\000\t\156\001\000\t\152\001\000\t\148\003\000\t\156\002\000\t\152\002\000\t\148\004\000\t\156\003\000\t\152\003\000\t\148\005\000\t\156\004\000\t\152\004\000\t\148\006\000\tL\001\000\t\148\001\000\t\144\003\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\003\020\002\000\003\016\002\000\t\156\001\000\t\152\001\000\003\020\003\000\t\156\002\000\t\152\002\000\003\020\004\000\t\156\003\000\t\152\003\000\003\020\005\000\t\156\004\000\t\152\004\000\tL\001\000\003\020\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\003\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\0034\002\000\0030\002\000\t\156\001\000\t\152\001\000\0034\003\000\t\156\002\000\t\152\002\000\0034\004\000\t\156\003\000\t\152\003\000\0034\005\000\t\156\004\000\t\152\004\000\tL\001\000\0034\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\003\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002\252\002\000\002\248\002\000\t\156\001\000\t\152\001\000\002\252\003\000\t\156\002\000\t\152\002\000\002\252\004\000\t\156\003\000\t\152\003\000\002\252\005\000\t\156\004\000\t\152\004\000\tL\001\000\002\252\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\003\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\003\004\002\000\003\000\002\000\t\156\001\000\t\152\001\000\003\004\003\000\t\156\002\000\t\152\002\000\003\004\004\000\t\156\003\000\t\152\003\000\003\004\005\000\t\156\004\000\t\152\004\000\tL\001\000\003\004\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\003\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\003\012\002\000\003\b\002\000\t\156\001\000\t\152\001\000\003\012\003\000\t\156\002\000\t\152\002\000\003\012\004\000\t\156\003\000\t\152\003\000\003\012\005\000\t\156\004\000\t\152\004\000\tL\001\000\003\012\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\003\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\003\144\002\000\n\196\001\000\002p\001\000\n\236\001\000\n\232\001\000\n\220\001\000\n\160\001\000\n\156\001\000\n\152\001\000\n\148\001\000\n\144\001\000\n\140\001\000\n\136\001\000\n\132\001\000\n\128\001\000\002p\002\000\003$\001\000\003 \001\000\t\156\001\000\t\152\001\000\003$\002\000\t\156\002\000\t\152\002\000\003$\003\000\t\156\003\000\t\152\003\000\003$\004\000\t\156\004\000\t\152\004\000\tL\001\000\003$\005\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003 \002\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\003\172\002\000\003\168\002\000\003\164\002\000\003\172\003\000\003\172\004\000\003\172\005\000\003\168\003\000\000L\001\000\000L\002\000\011$\001\000\004\136\001\000\004\132\001\000\004\128\001\000\004|\001\000\004x\001\000\012@\001\000\012@\002\000\012\216\001\000\012\212\001\000\004\136\002\000\004\132\002\000\004\136\003\000\004\136\004\000\004\136\005\000\004\136\006\000\001\180\001\000\004\136\007\000\004\136\b\000\t@\001\000\004\132\003\000\t@\002\000\t@\003\000\004\132\004\000\004\132\005\000\001\180\001\000\004\132\006\000\004\132\007\000\004\128\002\000\004\128\003\000\004\128\004\000\004|\002\000\012D\001\000\007\204\001\000\012D\002\000\012D\003\000\002\028\001\000\012D\004\000\t\028\001\000\011(\001\000\004\144\001\000\004\144\002\000\004\144\003\000\001\180\001\000\004\144\004\000\004\144\005\000\b\128\001\000\bx\001\000\bp\001\000\bl\001\000\bT\001\000\004\140\001\000\004\140\002\000\004\140\003\000\bT\002\000\bT\003\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\bl\002\000\bl\003\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\b\128\002\000\b\128\003\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\bx\002\000\bx\003\000\bp\002\000\bt\001\000\b|\001\000\bP\001\000\bP\002\000\bP\003\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\004t\001\000\000L\003\000\005\012\001\000\005\012\002\000\000L\004\000\004\152\002\000\t\148\001\000\t\144\001\000\t\136\003\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\b\128\001\000\bx\001\000\bp\001\000\bl\001\000\bT\001\000\004\188\001\000\004\188\002\000\004\188\003\000\004\196\001\000\003,\002\000\003,\003\000\003,\004\000\004\196\002\000\004\196\003\000\004\192\001\000\n\208\001\000\007 \001\000\n\224\004\000\n\224\005\000\011\016\003\000\011\012\003\000\011\016\004\000\011\012\004\000\011\012\005\000\t\192\001\000\t\180\001\000\t\176\001\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\t\192\002\000\t\180\002\000\t\192\003\000\011\028\003\000\011\024\003\000\011\028\004\000\011\024\004\000\011\024\005\000\n\228\003\000\n\228\004\000\n\228\005\000\011\000\003\000\n\236\001\000\n\232\001\000\n\220\001\000\n\160\001\000\n\156\001\000\n\152\001\000\n\148\001\000\n\144\001\000\n\140\001\000\n\136\001\000\n\132\001\000\n\128\001\000\b\224\001\000\b\224\002\000\b\224\003\000\t\232\001\000\t\228\001\000\t\224\001\000\t\232\002\000\t\228\002\000\t\224\002\000\t\232\003\000\t\228\003\000\t\224\003\000\t\232\004\000\t\228\004\000\t\232\005\000\b\220\001\000\011\000\004\000\011\000\005\000\011 \001\000\011\028\001\000\011\024\001\000\011\016\001\000\011\012\001\000\011\000\001\000\n\248\001\000\n\228\001\000\n\224\001\000\005\240\001\000\005\232\001\000\005\224\001\000\001\140\001\000\001\136\001\000\011 \002\000\011\028\002\000\011\024\002\000\011\016\002\000\011\012\002\000\011\000\002\000\n\248\002\000\n\228\002\000\n\224\002\000\005\240\002\000\005\232\002\000\005\224\002\000\001\140\002\000\r8\001\000\005\224\003\000\005\240\003\000\004@\001\000\n\236\001\000\n\232\001\000\n\220\001\000\n\160\001\000\n\156\001\000\n\152\001\000\n\148\001\000\n\144\001\000\n\140\001\000\n\136\001\000\n\132\001\000\n\128\001\000\004@\002\000\n\156\002\000\n\148\002\000\n\140\002\000\003\132\002\000\003\128\002\000\003t\002\000\003p\002\000\003d\002\000\003`\002\000\n\140\003\000\003d\003\000\003`\003\000\n\140\004\000\003d\004\000\003`\004\000\n\140\005\000\003d\005\000\003`\005\000\003d\006\000\003`\006\000\t\156\001\000\t\152\001\000\003d\007\000\t\156\002\000\t\152\002\000\003d\b\000\t\156\003\000\t\152\003\000\003d\t\000\t\156\004\000\t\152\004\000\tL\001\000\003d\n\000\t\148\001\000\t\144\001\000\003\144\001\000\003`\007\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\n\156\003\000\003\132\003\000\003\128\003\000\n\156\004\000\003\132\004\000\003\128\004\000\n\156\005\000\003\132\005\000\003\128\005\000\003\132\006\000\003\128\006\000\t\156\001\000\t\152\001\000\003\132\007\000\t\156\002\000\t\152\002\000\003\132\b\000\t\156\003\000\t\152\003\000\003\132\t\000\t\156\004\000\t\152\004\000\tL\001\000\003\132\n\000\t\148\001\000\t\144\001\000\003\144\001\000\003\128\007\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\n\148\003\000\003t\003\000\003p\003\000\n\148\004\000\003t\004\000\003p\004\000\n\148\005\000\003t\005\000\003p\005\000\003t\006\000\003p\006\000\t\156\001\000\t\152\001\000\003t\007\000\t\156\002\000\t\152\002\000\003t\b\000\t\156\003\000\t\152\003\000\003t\t\000\t\156\004\000\t\152\004\000\tL\001\000\003t\n\000\t\148\001\000\t\144\001\000\003\144\001\000\003p\007\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\n\220\002\000\n\160\002\000\n\152\002\000\n\144\002\000\n\136\002\000\n\132\002\000\n\128\002\000\003\140\002\000\003\136\002\000\003|\002\000\003x\002\000\003l\002\000\003h\002\000\003\\\002\000\003X\002\000\003T\002\000\003P\002\000\003L\002\000\003H\002\000\003D\002\000\003@\002\000\n\128\003\000\003L\003\000\003H\003\000\n\128\004\000\003L\004\000\003H\004\000\n\128\005\000\003L\005\000\003H\005\000\003L\006\000\003H\006\000\t\156\001\000\t\152\001\000\003L\007\000\t\156\002\000\t\152\002\000\003L\b\000\t\156\003\000\t\152\003\000\003L\t\000\t\156\004\000\t\152\004\000\tL\001\000\003L\n\000\t\148\001\000\t\144\001\000\003\144\001\000\003H\007\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\n\136\003\000\003\\\003\000\003X\003\000\n\136\004\000\003\\\004\000\003X\004\000\n\136\005\000\003\\\005\000\003X\005\000\003\\\006\000\003X\006\000\t\156\001\000\t\152\001\000\003\\\007\000\t\156\002\000\t\152\002\000\003\\\b\000\t\156\003\000\t\152\003\000\003\\\t\000\t\156\004\000\t\152\004\000\tL\001\000\003\\\n\000\t\148\001\000\t\144\001\000\003\144\001\000\003X\007\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\n\132\003\000\003T\003\000\003P\003\000\n\132\004\000\003T\004\000\003P\004\000\n\132\005\000\003T\005\000\003P\005\000\003T\006\000\003P\006\000\t\156\001\000\t\152\001\000\003T\007\000\t\156\002\000\t\152\002\000\003T\b\000\t\156\003\000\t\152\003\000\003T\t\000\t\156\004\000\t\152\004\000\tL\001\000\003T\n\000\t\148\001\000\t\144\001\000\003\144\001\000\003P\007\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\n\160\003\000\n\152\003\000\n\144\003\000\005\232\001\000\005\224\001\000\003\140\003\000\003\136\003\000\003|\003\000\003x\003\000\003l\003\000\003h\003\000\n\160\004\000\n\152\004\000\n\144\004\000\003\140\004\000\003\136\004\000\003|\004\000\003x\004\000\003l\004\000\003h\004\000\n\144\005\000\003l\005\000\003h\005\000\n\144\006\000\003l\006\000\003h\006\000\n\144\007\000\003l\007\000\003h\007\000\003l\b\000\003h\b\000\t\156\001\000\t\152\001\000\003l\t\000\t\156\002\000\t\152\002\000\003l\n\000\t\156\003\000\t\152\003\000\003l\011\000\t\156\004\000\t\152\004\000\tL\001\000\003l\012\000\t\148\001\000\t\144\001\000\003\144\001\000\003h\t\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\n\160\005\000\003\140\005\000\003\136\005\000\n\160\006\000\003\140\006\000\003\136\006\000\n\160\007\000\003\140\007\000\003\136\007\000\003\140\b\000\003\136\b\000\t\156\001\000\t\152\001\000\003\140\t\000\t\156\002\000\t\152\002\000\003\140\n\000\t\156\003\000\t\152\003\000\003\140\011\000\t\156\004\000\t\152\004\000\tL\001\000\003\140\012\000\t\148\001\000\t\144\001\000\003\144\001\000\003\136\t\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\n\152\005\000\003|\005\000\003x\005\000\n\152\006\000\003|\006\000\003x\006\000\n\152\007\000\003|\007\000\003x\007\000\003|\b\000\003x\b\000\t\156\001\000\t\152\001\000\003|\t\000\t\156\002\000\t\152\002\000\003|\n\000\t\156\003\000\t\152\003\000\003|\011\000\t\156\004\000\t\152\004\000\tL\001\000\003|\012\000\t\148\001\000\t\144\001\000\003\144\001\000\003x\t\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\n\220\003\000\003D\003\000\003@\003\000\003D\004\000\003@\004\000\t\156\001\000\t\152\001\000\003D\005\000\t\156\002\000\t\152\002\000\003D\006\000\t\156\003\000\t\152\003\000\003D\007\000\t\156\004\000\t\152\004\000\tL\001\000\003D\b\000\t\148\001\000\t\144\001\000\003\144\001\000\003@\005\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\n\236\001\000\n\232\001\000\n\220\001\000\n\160\001\000\n\156\001\000\n\152\001\000\n\148\001\000\n\144\001\000\n\140\001\000\n\136\001\000\n\132\001\000\n\128\001\000\004<\001\000\t0\001\000\002h\002\000\t0\002\000\t,\001\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\024\002\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\n\128\004\000\n\128\005\000\n\136\003\000\n\136\004\000\n\136\005\000\n\132\003\000\n\132\004\000\n\132\005\000\n\160\003\000\n\152\003\000\n\144\003\000\005\232\001\000\005\224\001\000\n\160\004\000\n\152\004\000\n\144\004\000\n\144\005\000\n\144\006\000\n\144\007\000\n\160\005\000\n\160\006\000\n\160\007\000\n\152\005\000\n\152\006\000\n\152\007\000\n\220\003\000\t\196\006\000\n\140\004\000\n\140\005\000\n\156\003\000\n\156\004\000\n\156\005\000\n\148\003\000\n\148\004\000\n\148\005\000\002\\\006\000\001\232\001\000\001\236\001\000\002\\\007\000\002\\\b\000\002\\\t\000\002\\\n\000\002\\\011\000\t\152\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\0024\007\000\005l\003\000\005l\004\000\005l\005\000\005p\002\000\005h\002\000\005p\003\000\005h\003\000\tH\002\000\t\240\004\000\t\156\004\000\t\152\004\000\tL\001\000\002T\004\000\002P\004\000\002L\004\000\002H\004\000\002D\004\000\002@\004\000\002T\005\000\002P\005\000\002L\005\000\002H\005\000\002D\005\000\002@\005\000\t\156\001\000\t\152\001\000\002T\006\000\002L\006\000\002H\006\000\t\156\002\000\t\152\002\000\002T\007\000\002L\007\000\002H\007\000\t\156\003\000\t\152\003\000\002T\b\000\002L\b\000\002H\b\000\t\156\004\000\t\152\004\000\tL\001\000\002T\t\000\002L\t\000\002H\t\000\002L\n\000\002H\n\000\t\156\001\000\t\152\001\000\002L\011\000\t\156\002\000\t\152\002\000\002L\012\000\t\156\003\000\t\152\003\000\002L\r\000\t\156\004\000\t\152\004\000\tL\001\000\002L\014\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002H\011\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002P\006\000\002D\006\000\002@\006\000\002D\007\000\002@\007\000\t\156\001\000\t\152\001\000\002D\b\000\t\156\002\000\t\152\002\000\002D\t\000\t\156\003\000\t\152\003\000\002D\n\000\t\156\004\000\t\152\004\000\tL\001\000\002D\011\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\002@\b\000\n\168\004\000\n\164\004\000\n\164\005\000\n\236\001\000\n\232\001\000\n\220\001\000\n\160\001\000\n\156\001\000\n\152\001\000\n\148\001\000\n\144\001\000\n\140\001\000\n\136\001\000\n\132\001\000\n\128\001\000\002d\004\000\np\002\000\t\156\001\000\t\152\001\000\np\003\000\t\156\002\000\t\152\002\000\np\004\000\t\156\003\000\t\152\003\000\np\005\000\t\156\004\000\t\152\004\000\tL\001\000\np\006\000\nl\002\000\t\148\001\000\t\144\001\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\nl\003\000\n\236\001\000\n\232\001\000\n\220\001\000\n\160\001\000\n\156\001\000\n\152\001\000\n\148\001\000\n\144\001\000\n\140\001\000\n\136\001\000\n\132\001\000\n\128\001\000\nt\002\000\n\252\002\000\n\252\003\000\t\156\001\000\t\152\001\000\007\172\002\000\t\156\002\000\t\152\002\000\007\172\003\000\t\156\003\000\t\152\003\000\007\172\004\000\t\156\004\000\t\152\004\000\tL\001\000\007\172\005\000\t\148\001\000\t\144\001\000\007\168\002\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\t\208\002\000\t\204\002\000\t\200\002\000\t\208\003\000\t\204\003\000\t\208\004\000\n\216\002\000\n\212\002\000\n\212\003\000\011\020\002\000\011\020\003\000\0020\b\000\002,\003\000\002,\004\000\006,\001\000\006(\001\000\006 \001\000\002,\005\000\002,\006\000\002,\007\000\002$\002\000\002$\003\000\002$\004\000\002$\005\000\006\000\001\000\006,\001\000\006(\001\000\006 \001\000\006\000\002\000\006\004\001\000\006d\001\000\006`\001\000\006T\001\000\006\004\002\000\006\004\003\000\006,\001\000\006(\001\000\006 \001\000\006\004\004\000\002$\006\000\002$\007\000\002$\b\000\006\b\001\000\006\b\002\000\002(\002\000\002(\003\000\002(\004\000\001|\001\000\001\128\001\000\001p\001\000\001\128\002\000\001\128\003\000\001l\001\000\002(\005\000\003\208\001\000\001\164\001\000\006|\001\000\004 \001\000\004\028\001\000\004 \002\000\004\028\002\000\004 \003\000\004\028\003\000\t@\001\000\b\172\001\000\b\172\002\000\b\172\003\000\000H\001\000\004 \004\000\004\028\004\000\004 \005\000\004\028\005\000\004 \006\000\004 \007\000\b\168\001\000\000H\001\000\001\164\002\000\001\164\003\000\004,\001\000\004(\001\000\004,\002\000\004$\001\000\t|\001\000\001\160\001\000\t|\002\000\001\160\002\000\t|\003\000\001\160\003\000\000l\001\000\000`\001\000\003\208\002\000\tx\001\000\001\156\001\000\000l\001\000\000`\001\000\003\224\001\000\003\220\001\000\003\216\001\000\003\212\001\000\t@\001\000\003\224\002\000\003\216\002\000\003\224\003\000\003\216\003\000\003\216\004\000\003\216\005\000\003\216\006\000\000l\001\000\000`\001\000\tx\001\000\003\224\004\000\001\156\001\000\000l\001\000\000`\001\000\003\212\002\000\003\212\003\000\003\212\004\000\000l\001\000\000`\001\000\tx\001\000\003\220\002\000\001\156\001\000\000l\001\000\000`\001\000\002(\006\000\002(\007\000\002(\b\000\002(\t\000\001\132\001\000\004\148\002\000\004\148\003\000\b\216\001\000\004\148\004\000\004\148\005\000\004\148\006\000\007\196\002\000\004T\004\000\004T\005\000\004X\002\000\004\176\002\000\t\156\001\000\t\152\001\000\003<\003\000\t\156\002\000\t\152\002\000\003<\004\000\t\156\003\000\t\152\003\000\003<\005\000\t\156\004\000\t\152\004\000\tL\001\000\003<\006\000\t\148\001\000\t\144\001\000\003\144\001\000\0038\003\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\011\b\002\000\011\004\002\000\011\004\003\000\n\236\001\000\n\232\001\000\n\220\001\000\n\204\002\000\n\160\001\000\n\156\001\000\n\152\001\000\n\148\001\000\n\144\001\000\n\140\001\000\n\136\001\000\n\132\001\000\n\128\001\000\n\180\002\000\n\176\002\000\n\180\003\000\n\176\003\000\n\180\004\000\n\176\004\000\n\180\005\000\n\176\005\000\006,\001\000\006(\001\000\006 \001\000\n\176\006\000\n\180\006\000\n\180\007\000\006d\001\000\006`\001\000\006T\001\000\n\180\b\000\n|\002\000\nx\002\000\nx\003\000\n|\003\000\n|\004\000\0028\004\000\0028\005\000\tL\001\000\0028\006\000\t\156\001\000\t\152\001\000\007\252\004\000\007\244\004\000\007\236\004\000\007\228\004\000\t\156\002\000\t\152\002\000\007\252\005\000\007\244\005\000\007\236\005\000\007\228\005\000\t\156\003\000\t\152\003\000\007\252\006\000\007\244\006\000\007\236\006\000\007\228\006\000\t\156\004\000\t\152\004\000\tL\001\000\007\252\007\000\007\244\007\000\007\236\007\000\007\228\007\000\007\228\b\000\007\252\b\000\007\252\t\000\006d\001\000\006`\001\000\006T\001\000\007\252\n\000\007\244\b\000\007\236\b\000\007\244\t\000\007\236\t\000\006d\001\000\006`\001\000\006T\001\000\007\236\n\000\007\244\n\000\007\244\011\000\006d\001\000\006`\001\000\006T\001\000\007\244\012\000\t\148\001\000\t\144\001\000\007\248\004\000\007\240\004\000\007\232\004\000\007\224\004\000\003\144\001\000\0034\001\000\0030\001\000\003\020\001\000\003\016\001\000\003\012\001\000\003\b\001\000\003\004\001\000\003\000\001\000\002\252\001\000\002\248\001\000\002\244\001\000\002\240\001\000\002\236\001\000\002\232\001\000\002\228\001\000\002\224\001\000\002\220\001\000\002\216\001\000\002\212\001\000\002\208\001\000\002\204\001\000\002\200\001\000\002\196\001\000\002\192\001\000\002\188\001\000\002\184\001\000\002\180\001\000\002\176\001\000\002\172\001\000\002\168\001\000\002\164\001\000\002\160\001\000\002\156\001\000\002\152\001\000\002\148\001\000\002\144\001\000\002\140\001\000\002\136\001\000\002\132\001\000\002\128\001\000\002|\001\000\002x\001\000\007\224\005\000\007\248\005\000\007\248\006\000\006d\001\000\006`\001\000\006T\001\000\007\248\007\000\007\240\005\000\007\232\005\000\007\240\006\000\007\232\006\000\006d\001\000\006`\001\000\006T\001\000\007\232\007\000\007\240\007\000\007\240\b\000\006d\001\000\006`\001\000\006T\001\000\007\240\t\000\006\236\005\000\006,\001\000\006(\001\000\006 \001\000\006\236\006\000\006\232\002\000\006\232\003\000\006\232\004\000\006,\001\000\006(\001\000\006 \001\000\006\232\005\000\012x\001\000\012t\001\000\006l\001\000\006l\002\000\006l\003\000\006l\004\000\006l\005\000\007\180\001\000\007\180\002\000\006d\001\000\006`\001\000\006T\001\000\006l\006\000\006l\007\000\012x\002\000\012t\002\000\012x\003\000\012t\003\000\012x\004\000\012x\005\000\012x\006\000\012x\007\000\004\228\001\000\004\228\002\000\004\228\003\000\004\228\004\000\004\228\005\000\004\228\006\000\012x\b\000\012t\004\000\012t\005\000\012t\006\000\004\020\001\000\004\020\002\000\b\156\001\000\b\152\001\000\b\156\002\000\b\152\002\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\b\156\003\000\b\156\004\000\002\012\001\000\002\012\002\000\012\140\001\000\012\140\002\000\012\140\003\000\012\140\004\000\006,\001\000\006(\001\000\006 \001\000\012\140\005\000\b\180\001\000\b\180\002\000\b\180\003\000\b\180\004\000\b\180\005\000\t@\001\000\b\164\001\000\b\164\002\000\b\164\003\000\001\180\001\000\b\180\006\000\b\180\007\000\006\164\001\000\006\160\001\000\006\164\002\000\b\180\b\000\b\180\t\000\b\160\001\000\001\180\001\000\012<\001\000\t\244\001\000\012<\002\000\t\244\002\000\012<\003\000\t\244\003\000\012<\004\000\t\244\004\000\012<\005\000\001\144\001\000\001p\001\000\005\232\001\000\001\140\001\000\001\136\001\000\005\232\002\000\001\140\002\000\001\140\003\000\012<\006\000\012<\007\000\012<\b\000\t\244\005\000\t\244\006\000\t\244\007\000\b\148\001\000\b\144\001\000\005\020\001\000\006\244\001\000\006\240\001\000\006\244\002\000\006\244\003\000\006\244\004\000\006\244\005\000\005\248\001\000\005\184\001\000\006\244\006\000\006\240\002\000\006\240\003\000\006\240\004\000\005\248\001\000\005\184\001\000\006\240\005\000\n,\001\000\n$\001\000\n \001\000\006p\001\000\006l\001\000\006@\001\000\006p\002\000\006l\002\000\006p\003\000\006l\003\000\006p\004\000\006l\004\000\006p\005\000\006l\005\000\006p\006\000\006p\007\000\006d\001\000\006`\001\000\006T\001\000\006p\b\000\n,\002\000\n$\002\000\n \002\000\006@\002\000\n,\003\000\n$\003\000\n \003\000\006@\003\000\006@\004\000\0068\001\000\006@\005\000\006@\006\000\005\248\001\000\005\184\001\000\006@\007\000\n,\004\000\n,\005\000\n,\006\000\n,\007\000\006d\001\000\006`\001\000\006T\001\000\n,\b\000\004\236\001\000\004\236\002\000\004\236\003\000\004\236\004\000\006d\001\000\006`\001\000\006T\001\000\004\236\005\000\004\236\006\000\004\236\007\000\n,\t\000\n$\004\000\n \004\000\n$\005\000\n$\006\000\005\232\001\000\n$\007\000\006\012\001\000\006d\001\000\006`\001\000\006T\001\000\006\012\002\000\n \005\000\n \006\000\006\016\001\000\006\016\002\000\n<\001\000\n<\002\000\n<\003\000\n<\004\000\006d\001\000\006`\001\000\006T\001\000\n<\005\000\t\244\001\000\t\244\002\000\t\244\003\000\t\244\004\000\n@\001\000\001T\001\000\001T\002\000\001T\003\000\001T\004\000\r`\001\000\001T\005\000\002\020\001\000\tt\001\000\002\020\002\000\002\020\003\000\001T\006\000\001T\007\000\001T\b\000\001 \001\000\001 \002\000\000\244\001\000\001\180\001\000\000\244\002\000\000\244\003\000\001 \003\000\001\000\001\000\001\000\002\000\006\144\001\000\006\136\001\000\006\144\002\000\006\140\001\000\006\132\001\000\006\140\002\000\001\000\003\000\001\000\004\000\001\000\005\000\001\180\001\000\001\000\006\000\001\000\007\000\001\004\001\000\001\004\002\000\b\208\001\000\b\200\001\000\b\208\002\000\b\204\001\000\b\196\001\000\b\204\002\000\001\004\003\000\001\004\004\000\001\004\005\000\001\004\006\000\001\004\007\000\000\252\001\000\000\252\002\000\001,\001\000\001(\001\000\001,\002\000\001(\002\000\001,\003\000\001,\004\000\005\232\001\000\001,\005\000\001,\006\000\001\024\001\000\tl\001\000\001\024\002\000\001\024\003\000\001\024\004\000\tl\002\000\tl\003\000\001\180\001\000\th\001\000\001\180\001\000\001\028\001\000\001\020\001\000\001,\007\000\001$\001\000\001$\002\000\001(\003\000\005\232\001\000\001(\004\000\001(\005\000\001(\006\000\001$\001\000\001$\001\000\000\252\003\000\000\252\004\000\001\b\001\000\001\b\002\000\001\180\001\000\001\152\001\000\001\152\002\000\001\180\001\000\001\152\003\000\001\b\003\000\001\b\004\000\001 \004\000\001 \005\000\001\012\001\000\001\012\002\000\001\016\001\000\0050\001\000\0050\002\000\001T\t\000\001$\001\000\001T\n\000\004\220\001\000\004\220\002\000\004\220\003\000\004\220\004\000\004\220\005\000\004\220\006\000\004\220\007\000\001$\001\000\004\220\b\000\004\220\t\000\001T\011\000\n@\002\000\n@\003\000\n@\004\000\n@\005\000\n@\006\000\n@\007\000\005\172\001\000\001L\001\000\001L\002\000\001L\003\000\001L\004\000\001\212\001\000\001\208\001\000\001\204\001\000\001\024\001\000\t\172\001\000\th\001\000\001\180\001\000\001P\001\000\001P\002\000\001H\001\000\001H\002\000\001H\003\000\012\232\001\000\001X\001\000\002\b\001\000\001\028\001\000\001H\004\000\001D\001\000\001$\001\000\001P\003\000\001L\005\000\n@\b\000\n@\t\000\004\212\001\000\004\212\002\000\004\212\003\000\004\212\004\000\004\212\005\000\004\212\006\000\004\212\007\000\004\212\b\000\004\212\t\000\n@\n\000\n\004\001\000\005\024\001\000\n\028\001\000\n\b\001\000\n8\001\000\n4\001\000\n0\001\000\n(\001\000\005\024\002\000\t\252\001\000\t\252\002\000\n\012\001\000\004\252\001\000\004\252\002\000\004\252\003\000\004\252\004\000\004\252\005\000\t\024\001\000\004\252\006\000\004\252\007\000\004\252\b\000\n\012\002\000\n\016\001\000\005\004\001\000\005\004\002\000\005\004\003\000\005\004\004\000\005\004\005\000\001\212\001\000\001\208\001\000\001\204\001\000\001l\001\000\006\208\001\000\006\208\002\000\006\208\003\000\006\192\001\000\003\228\001\000\001\168\001\000\003\228\002\000\003\228\003\000\003\228\004\000\b\236\001\000\001\172\001\000\003\228\001\000\b\236\002\000\005\004\006\000\t\024\001\000\005\004\007\000\005\004\b\000\005\004\t\000\b\228\001\000\b\232\001\000\006\220\001\000\006\216\001\000\006\204\001\000\006\200\001\000\006\188\001\000\006\184\001\000\006\168\001\000\001\180\001\000\006\220\002\000\006\216\002\000\006\204\002\000\006\200\002\000\006\188\002\000\006\184\002\000\006\220\003\000\006\204\003\000\006\188\003\000\006\220\004\000\006\220\005\000\006\220\006\000\006\204\004\000\006\188\004\000\003\232\001\000\003\232\002\000\003\232\003\000\006\216\003\000\006\216\004\000\006\216\005\000\006\200\003\000\006\184\003\000\006\176\001\000\n\016\002\000\n\000\001\000\nD\001\000\005\020\002\000\b\144\002\000\t\248\001\000\b\148\002\000\001\180\001\000\012\132\001\000\001T\001\000\012\132\002\000\012\132\003\000\012\132\004\000\012\132\005\000\012\132\006\000\000\208\001\000\001@\001\000\001@\002\000\001@\003\000\000\184\001\000\rT\001\000\rL\001\000\rT\002\000\rL\002\000\rT\003\000\rL\003\000\rT\004\000\rL\004\000\rL\005\000\rL\006\000\rT\005\000\rT\006\000\rT\007\000\000\184\002\000\000\184\003\000\rP\001\000\rH\001\000\rD\001\000\rl\001\000\rd\001\000\rl\002\000\rh\001\000\006|\001\000\rh\002\000\rD\002\000\rD\003\000\rD\004\000\rD\005\000\001\180\001\000\rP\002\000\rH\002\000\rP\003\000\rH\003\000\rH\004\000\rH\005\000\rP\004\000\rP\005\000\rP\006\000\000\188\001\000\005\168\001\000\005\160\001\000\005\152\001\000\005\168\002\000\005\160\002\000\005\152\002\000\b\188\001\000\005\168\003\000\005\160\003\000\005\152\003\000\005\168\004\000\005\160\004\000\005\152\004\000\005\168\005\000\005\160\005\000\005\168\006\000\005\168\007\000\005\168\b\000\005\168\t\000\001\180\001\000\005\168\n\000\005\168\011\000\005\160\006\000\005\160\007\000\005\160\b\000\005\152\005\000\000\188\002\000\000\188\003\000\005\164\001\000\005\156\001\000\005\148\001\000\005\144\001\000\rx\001\000\rp\001\000\rx\002\000\rt\001\000\b\188\001\000\rt\002\000\005\144\002\000\005\144\003\000\005\144\004\000\005\144\005\000\005\164\002\000\005\156\002\000\005\148\002\000\005\164\003\000\005\156\003\000\005\148\003\000\005\164\004\000\005\156\004\000\005\164\005\000\005\164\006\000\005\164\007\000\005\164\b\000\001\180\001\000\005\164\t\000\005\164\n\000\005\156\005\000\005\156\006\000\005\156\007\000\005\148\004\000\000\196\001\000\000\196\002\000\000\196\003\000\000\196\004\000\000\180\001\000\000\176\001\000\000\180\002\000\000\180\003\000\001<\001\000\0010\001\000\004\160\001\000\004\156\001\000\000\160\001\000\000\156\001\000\004\160\002\000\004\160\003\000\004\160\004\000\004\160\005\000\004\160\006\000\004\160\007\000\000\160\002\000\000\156\002\000\000\160\003\000\000\160\004\000\005\232\001\000\000\160\005\000\000\160\006\000\0018\001\000\tl\001\000\0018\002\000\0018\003\000\0018\004\000\000\148\001\000\000\148\002\000\000\224\001\000\000\220\001\000\000\220\002\000\004\164\001\000\000\152\001\000\000\152\002\000\000\172\001\000\000\168\001\000\000\144\001\000\t0\001\000\000\168\002\000\0014\001\000\000\164\001\000\000\152\003\000\000\164\002\000\004\164\002\000\000\220\003\000\000\164\001\000\000\224\002\000\000\148\003\000\000\164\001\000\000\160\007\000\000\156\003\000\005\232\001\000\000\156\004\000\000\156\005\000\000\164\001\000\000\156\006\000\004\156\002\000\004\156\003\000\004\156\004\000\004\156\005\000\001<\002\000\0010\002\000\000\164\001\000\0010\003\000\001<\003\000\001<\004\000\001<\005\000\000\180\004\000\000\164\001\000\007\144\001\000\007\144\002\000\000\180\005\000\000\180\006\000\000\176\002\000\000\176\003\000\000\164\001\000\000\176\004\000\000\176\005\000\000\192\001\000\000\192\002\000\000\192\003\000\000\192\004\000\001@\004\000\001@\005\000\000\200\001\000\000\200\002\000\000\204\001\000\0058\001\000\0058\002\000\000\208\002\000\000\164\001\000\000\212\001\000\000\212\002\000\000\212\003\000\000\212\004\000\000\164\001\000\000\216\001\000\000\216\002\000\012\132\007\000\012\132\b\000\004\204\001\000\004\204\002\000\004\204\003\000\004\204\004\000\004\204\005\000\004\204\006\000\004\204\007\000\004\204\b\000\012\132\t\000\012`\001\000\005(\001\000\004\148\001\000\012p\001\000\0128\001\000\012\\\001\000\012\128\001\000\012|\001\000\005(\002\000\012P\001\000\004\152\001\000\012T\001\000\012T\002\000\012d\001\000\012d\002\000\012X\001\000\012\136\001\000\b\140\001\000\012L\001\000\012L\002\000\012L\003\000\000\136\001\000\012H\001\000\012P\001\000\004\152\001\000\003(\001\000\002\012\003\000\002\012\004\000\004\020\003\000\004\020\004\000\005$\002\000\005$\003\000\005$\004\000\005 \002\000\006\020\003\000\006\020\004\000\006L\005\000\006,\001\000\006(\001\000\006 \001\000\0118\007\000\006d\001\000\006`\001\000\006T\001\000\0118\b\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\000\236\002\000\000\232\002\000\000\232\003\000\000\236\003\000\001\180\001\000\000\236\004\000\000\236\005\000\n\184\004\000\n\184\005\000\n\184\006\000\002<\004\000\002<\005\000\tL\001\000\002<\006\000\b\176\003\000\b\176\004\000\003\248\t\000\012l\006\000\012l\007\000\012l\b\000\003\228\001\000\002\000\001\000\003\228\002\000\002\000\002\000\002\000\003\000\002\000\004\000\002\000\005\000\012l\t\000\t\004\001\000\t\000\001\000\012l\n\000\t\000\002\000\t\004\002\000\b\240\001\000\b\248\001\000\b\244\001\000\b\252\001\000\003\232\001\000\002\004\001\000\002\004\002\000\002\004\003\000\002\004\004\000\012h\004\000\003\244\004\000\005\172\001\000\003\244\005\000\003\244\006\000\t\024\001\000\003\244\007\000\003\244\b\000\012h\005\000\012h\006\000\012h\007\000\012h\b\000\t\004\001\000\t\000\001\000\012h\t\000\001\248\003\000\001\248\004\000\005\132\003\000\005|\003\000\005t\003\000\005\132\004\000\005|\004\000\005t\004\000\005|\005\000\005t\005\000\005|\006\000\005t\006\000\005\140\001\000\005t\007\000\005\136\001\000\005\128\001\000\005x\001\000\000l\001\000\000`\001\000\005\128\002\000\005x\002\000\005x\003\000\006\228\002\000\006\224\002\000\006\224\003\000\003\184\003\000\003\184\004\000\003\184\005\000\t\128\001\000\000p\002\000\000d\002\000\000p\003\000\000d\003\000\000p\004\000\000p\005\000\000d\004\000\t\128\002\000\t\128\003\000\001\180\001\000\t\132\001\000\001\196\002\000\001\180\001\000\t\132\002\000\t\132\003\000\001\180\001\000\006\212\002\000\006\212\003\000\006\212\004\000\006\196\002\000\006\172\002\000\001\180\001\000\006\180\002\000\012\228\002\000\003\240\007\000\003\240\b\000\t\024\001\000\003\240\t\000\003\240\n\000\n\024\006\000\n\024\007\000\n\024\b\000\n\024\t\000\t\016\001\000\n\024\n\000\t\016\002\000\t\b\001\000\t\012\001\000\n\020\004\000\003\244\004\000\003\236\004\000\005\172\001\000\003\244\005\000\003\236\005\000\003\236\006\000\003\236\007\000\t\024\001\000\003\236\b\000\003\236\t\000\n\020\005\000\n\020\006\000\n\020\007\000\n\020\b\000\t\016\001\000\n\020\t\000\006D\003\000\006D\004\000\006d\001\000\006`\001\000\006T\001\000\001\200\005\000\001\200\006\000\rX\006\000\rX\007\000\000\140\003\000\000\140\004\000\002X\003\000\002X\004\000\002X\005\000\002X\006\000\002X\007\000\004\004\001\000\004\004\002\000\000\000\001\000\000\004\000\000\004\016\001\000\004\016\002\000\000\004\001\000\000\b\000\000\r4\001\000\005\192\001\000\001p\001\000\005\192\002\000\005\192\003\000\005\196\001\000\000\b\001\000\005\248\001\000\005\208\001\000\005\204\001\000\005\200\001\000\005\184\001\000\005\208\002\000\005\204\002\000\005\200\002\000\005\184\002\000\r4\001\000\005\204\003\000\005\204\004\000\005\204\005\000\005\208\003\000\005\200\003\000\000P\001\000\005\188\001\000\000T\001\000\b\000\001\000\b\000\002\000\000\012\000\000\000\012\001\000\b\004\001\000\b\004\002\000\000\016\000\000\000\016\001\000\b\b\001\000\001\180\001\000\b\b\002\000\000\020\000\000\b\012\001\000\b\012\002\000\000\020\001\000\000\024\000\000\000\024\001\000\b\016\001\000\005\248\001\000\005\184\001\000\b\016\002\000\000\028\000\000\000\028\001\000\b\020\001\000\005\232\001\000\b\020\002\000\000 \000\000\000 \001\000\b\024\001\000\006,\001\000\006(\001\000\006 \001\000\b\024\002\000\000$\000\000\000$\001\000\b\028\001\000\006d\001\000\006`\001\000\006T\001\000\b\028\002\000\000(\000\000\000(\001\000\b \001\000\b \002\000\000,\000\000\bL\001\000\b@\001\000\b8\001\000\b0\001\000\b,\001\000\b$\001\000\b$\002\000\000,\001\000\0000\000\000\b(\001\000\b(\002\000\0000\001\000\005\240\001\000\005\232\001\000\005\240\002\000\005\232\002\000\0004\000\000\012\184\001\000\012\180\001\000\012\176\001\000\012\172\001\000\012\168\001\000\012\164\001\000\012\160\001\000\012\184\002\000\012\180\002\000\012\176\002\000\012\172\002\000\012\168\002\000\012\164\002\000\012\160\002\000\012\184\003\000\012\164\003\000\012\168\003\000\012\180\003\000\012\172\003\000\012\176\003\000\005\240\001\000\005\232\001\000\012\200\001\000\0004\001\000\012\196\001\000\012\196\002\000\005@\001\000\005@\002\000\012\188\001\000\012\188\002\000\012\188\003\000\012\192\001\000\012\192\002\000\0008\000\000\005L\001\000\005H\001\000\005T\001\000\005P\001\000\005P\002\000\005T\002\000\005L\002\000\005L\003\000\005L\004\000\005H\002\000\0008\001\000\r0\001\000\r0\002\000\r0\003\000\r0\004\000\r,\001\000\r,\002"), (16, "\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\b\000\t\000\n\000\011\000\012\000\r\000\014\000\015\000\016\000\017\000\018\000\019\000\020\000\021\000\022\000\023\000\024\000\025\000\026\000\027\000\028\000\029\000\030\000\031\000 \000!\000\"\000#\000$\000%\000&\000'\000(\000)\000*\000+\000,\000-\000.\000/\0000\0001\0002\0003\0004\0005\0006\0008\0009\000:\000;\000<\000=\000>\000?\000@\000A\000B\000C\000D\000E\000F\000G\000H\000I\000J\000K\000L\000M\000N\000O\000P\000Q\000R\000S\000T\000U\000[\000]\000^\000_\000a\000c\000d\000f\000h\000j\000k\000m\000o\000q\000r\000s\000t\000u\000v\000w\000x\000y\000z\000{\000|\000}\000~\000\127\000\128\000\130\000\131\000\132\000\134\000\135\000\136\000\137\000\138\000\142\000\143\000\144\000\145\000\146\000\147\000\149\000\150\000\151\000\157\000\163\000\169\000\170\000\172\000\173\000\176\000\178\000\179\000\180\000\181\000\184\000\185\000\186\000\187\000\188\000\189\000\190\000\191\000\192\000\194\000\195\000\196\000\197\000\200\000\203\000\204\000\206\000\207\000\211\000\217\000\218\000\220\000\221\000\222\000\224\000\228\000\231\000\232\000\233\000\234\000\235\000\239\000\243\000\247\000\249\000\251\000\253\000\254\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\b\001\t\001\n\001\012\001\r\001\015\001\016\001\017\001\019\001\020\001\021\001\028\001\031\001!\001#\001%\001&\001'\001)\001*\001+\001,\001-\001.\001/\0010\0011\0012\0014\0015\0016\0017\0019\001:\001;\001<\001F\001N\001V\001W\001X\001Y\001Z\001\\\001^\001_\001`\001a\001b\001c\001d\001e\001f\001g\001h\001i\001j\001q\001s\001u\001x\001z\001{\001}\001\127\001\128\001\129\001\130\001\131\001\132\001\136\001\137\001\139\001\140\001\142\001\144\001\145\001\146\001\149\001\150\001\153\001\154\001\157\001\158\001\159\001\160\001\161\001\163\001\164\001\165\001\166\001\167\001\168\001\169\001\170\001\172\001\173\001\175\001\176\001\177\001\181\001\184\001\186\001\187\001\188\001\189\001\190\001\191\001\192\001\193\001\194\001\195\001\199\001\200\001\203\001\204\001\205\001\206\001\207\001\209\001\210\001\211\001\213\001\214\001\215\001\216\001\217\001\220\001\221\001\222\001\223\001\225\001\226\001\227\001\228\001\230\001\231\001\232\001\233\001\235\001\236\001\238\001\239\001\241\001\242\001\244\001\246\001\247\001\248\001\249\001\251\001\252\001\254\001\255\002\002\002\003\002\004\002\006\002\007\002\b\002\t\002\011\002\015\002\016\002\017\002\018\002\019\002\020\002\021\002\022\002\023\002\024\002\025\002\026\002\027\002\028\002\029\002\030\002 \002!\002\"\002#\002$\002+\0021\0024\0025\0026\0027\0028\0029\002:\002<\002=\002C\002D\002J\002K\002Q\002R\002X\002Y\002Z\002[\002]\002c\002d\002g\002o\002p\002r\002s\002t\002u\002v\002w\002x\002{\002|\002}\002\132\002\133\002\134\002\136\002\137\002\143\002\149\002\150\002\151\002\157\002\158\002\160\002\161\002\162\002\163\002\171\002\173\002\174\002\175\002\181\002\185\002\188\002\189\002\190\002\191\002\192\002\193\002\194\002\195\002\198\002\200\002\201\002\203\002\204\002\206\002\207\002\208\002\209\002\211\002\212\002\213\002\214\002\219\002\221\002\222\002\223\002\224\002\225\002\226\002\228\002\229\002\230\002\231\002\233\002\234\002\235\002\236\002\237\002\239\002\240\002\241\002\242\002\243\002\247\002\248\002\250\002\252\002\254\003\000\003\001\003\002\003\004\003\005\003\007\003\t\003\n\003\012\003\r\003\015\003\016\003\020\003\022\003\024\003\025\003\029\003\030\003\"\003#\003&\003(\003*\003+\003,\003-\003.\003/\0033\0036\0037\003:\003;\003<\003?\003@\003B\003C\003D\003E\003I\003M\003N\003R\003S\003T\003U\003V\003Z\003e\003f\003k\003l\003m\003q\003r\003s\003t\003v\003w\003{\003|\003~\003\128\003\131\003\133\003\134\003\136\003\137\003\139\003\140\003\141\003\142\003\144\003\146\003\148\003\154\003\160\003\166\003\169\003\172\003\175\003\176\003\184\003\185\003\186\003\187\003\188\003\190\003\191\003\192\003\199\003\200\003\202\003\203\003\204\003\205\003\206\003\207\003\215\003\216\003\217\003\218\003\219\003\220\003\221\003\223\003\224\003\225\003\226\003\227\003\230\003\231\003\232\003\235\003\238\003\241\003\245\003\247\003\250\003\253\004\000\004\004\004\005\004\006\004\007\004\b\004\t\004\n\004\016\004\017\004\018\004\019\004\020\004!\004\"\004/\0040\0041\0044\0045\004:\004?\004D\004J\004L\004M\004N\004O\004\\\004c\004d\004f\004i\004l\004o\004s\004\149\004\151\004\152\004\153\004\154\004\156\004\158\004\161\004\162\004\164\004\165\004\166\004\167\004\168\004\169\004\170\004\183\004\184\004\197\004\209\004\214\004\215\004\217\004\219\004\220\004\221\004\222\004\226\004\227\004\231\004\232\004\234\004\236\004\238\004\240\004\241\004\243\004\244\004\245\004\248\004\250\004\253\005\000\005\003\005\007\005\t\005\022\005\023\005\024\005\025\005\026\005\028\005\029\005\030\005\031\005P\005R\005U\005X\005[\005_\005\141\005\143\005\146\005\149\005\152\005\156\005\202\005\204\005\207\005\210\005\213\005\217\006\007\006\t\006\012\006\015\006\018\006\022\006D\006F\006I\006L\006O\006S\006\129\006\131\006\134\006\137\006\140\006\144\006\190\006\192\006\195\006\198\006\201\006\205\006\251\006\253\007\000\007\003\007\006\007\n\0078\007:\007=\007@\007C\007G\007u\007w\007z\007}\007\128\007\132\007\178\007\180\007\183\007\186\007\189\007\193\007\239\007\241\007\244\007\247\007\250\007\254\b,\b.\b1\b4\b7\b;\bi\bk\bn\bq\bt\bx\b\166\b\168\b\171\b\174\b\177\b\181\b\227\b\229\b\232\b\235\b\238\b\242\t \t\"\t%\t(\t+\t/\t]\t_\tb\te\th\tl\t\154\t\156\t\159\t\162\t\165\t\169\t\215\t\217\t\220\t\223\t\226\t\230\n\020\n\022\n\025\n\028\n\031\n#\nQ\nS\nV\nY\n\\\n`\n\142\n\143\n\145\n\158\n\160\n\163\n\166\n\169\n\173\n\219\n\222\n\223\n\224\n\225\n\226\n\227\n\228\n\234\n\235\n\236\n\240\n\241\n\242\n\243\n\245\n\246\n\247\n\249\n\250\n\251\n\252\n\254\n\255\011\000\011\001\011\002\011\003\011\004\011\005\011\006\011\007\011\b\011\t\011\n\011\011\011\r\011\014\011\016\011\017\011\018\011\024\011\025\011\026\011\027\011!\011\"\011(\011)\011/\0110\0111\0112\0113\0115\0116\011<\011=\011>\011?\011@\011A\011B\011p\011v\011w\011x\011z\011{\011|\011}\011~\011\127\011\129\011\130\011\131\011\133\011\134\011\135\011\136\011\184\011\186\011\187\011\189\011\190\011\191\011\192\011\193\011\194\011\195\011\196\011\209\011\210\011\211\011\214\011\217\011\220\011\222\011\223\011\224\011\225\011\226\011\240\011\253\011\255\012\000\012\001\012\014\012\023\012\026\012\029\012 \012\"\012%\012(\012+\012/\012]\012`\012c\012f\012h\012k\012n\012q\012u\012\163\012\166\012\169\012\172\012\174\012\177\012\180\012\183\012\187\012\233\012\254\r\001\r\004\r\007\r\t\r\012\r\015\r\018\r\022\rD\rG\rJ\rM\rO\rR\rU\rX\r\\\r\138\r\141\r\144\r\147\r\149\r\152\r\155\r\158\r\162\r\208\r\219\r\228\r\231\r\234\r\237\r\239\r\242\r\245\r\248\r\252\014*\014-\0140\0143\0145\0148\014;\014>\014B\014p\014s\014v\014y\014{\014~\014\129\014\132\014\136\014\182\014\185\014\187\014\190\014\193\014\196\014\200\014\246\015\003\015\005\015\006\015\007\0155\0156\0157\0158\0159\015:\015;\015<\015=\015B\015E\015F\015G\015H\015I\015J\015K\015L\015M\015N\015O\015P\015Q\015R\015S\015T\015U\015V\015W\015X\015Y\015Z\015[\015\\\015]\015^\015_\015`\015\142\015\143\015\144\015\145\015\146\015\148\015\149\015\150\015\151\015\155\015\161\015\167\015\172\015\177\015\182\015\188\015\190\015\193\015\196\015\199\015\203\015\249\016)\016+\016.\0161\0164\0168\016f\016g\016h\016i\016v\016y\016|\016\127\016\131\016\132\016\178\016\179\016\192\016\193\016\194\016\197\016\200\016\203\016\207\016\253\017\000\017\002\017\003\017\004\017\005\017\006\017\007\017\b\017\t\017\n\017\011\017\015\017\016\017\017\017\018\017\019\017\020\017\021\017\022\017\026\017\027\017\031\017 \017$\017%\017&\017'\017(\017)\017*\017+\017,\017-\017/\0170\0171\0172\0173\0174\0175\0176\0178\017:\017<\017>\017?\017A\017C\017E\017F\017G\017I\017J\017K\017M\017N\017O\017Q\017S\017W\017X\017\\\017`\017c\017e\017f\017g\017j\017o\017p\017q\017t\017y\017z\017{\017|\017}\017~\017\127\017\128\017\129\017\130\017\131\017\132\017\133\017\134\017\135\017\136\017\137\017\140\017\143\017\146\017\150\017\196\017\197\017\198\017\199\017\212\017\214\017\216\017\218\017\223\017\224\017\225\017\229\017\230\017\232\017\233\017\234\017\235\017\236\017\237\017\239\017\245\017\251\018\001\018\b\018\t\018\n\018\014\018\015\018\017\018\022\018\023\018\024\018\028\018\029\018N\018O\018P\018T\018U\018W\018\\\018]\018^\018b\018c\018g\018h\018i\018j\018n\018o\018r\018s\018t\018u\018v\018w\018{\018|\018}\018\127\018\129\018\130\018\131\018\132\018\133\018\134\018\135\018\136\018\137\018\138\018\139\018\140\018\141\018\142\018\143\018\144\018\145\018\147\018\154\018\155\018\156\018\157\018\158\018\159\018\160\018\161\018\165\018\166\018\167\018\168\018\169\018\170\018\171\018\173\018\174\018\176\018\177\018\178\018\180\018\181\018\182\018\183\018\185\018\187\018\189\018\191\018\193\018\194\018\196\018\199\018\201\018\202\018\203\018\204\018\205\018\206\018\207\018\208\018\210\018\211\018\213\018\214\018\215\018\216\018\219\018\220\018\221\018\222\018\225\018\226\018\232\018\234\018\236\018\238\018\240\018\241\018\245\018\246\018\250\018\254\019\000\019\001\019\004\019\005\019\006\019\007\019\b\019\012\019\r\019\014\019\015\019\016\019\017\019\021\019\022\019\023\019\024\019\026\019\027\019\029\019\030\019\031\019#\019$\019%\019&\019'\019(\019)\019*\019.\019/\0190\0191\0192\0193\0195\0196\0197\0198\0199\019:\019;\019=\019>\019?\019@\019A\019B\019C\019D\019F\019G\019H\019I\019J\019L\019M\019O\019P\019Q\019R\019S\019U\019V\019W\019X\019Z\019[\019]\019^\019_\019`\019a\019b\019c\019d\019e\019g\019i\019j\019k\019m\019n\019o\019q\019r\019s\019t\019v\019x\019y\019z\019|\019}\019~\019\128\019\129\019\131\019\133\019\134\019\135\019\136\019\138\019\139\019\141\019\142\019\143\019\144\019\145\019\146\019\147\019\148\019\149\019\150\019\152\019\153\019\154\019\155\019\156\019\157\019\158\019\159\019\161\019\162\019\163\019\164\019\165\019\166\019\167\019\168\019\169\019\170\019\172\019\173\019\174\019\175\019\179\019\182\019\183\019\184\019\185\019\186\019\187\019\189\019\191\019\192\019\194\019\195\019\196\019\197\019\198\019\199\019\200\019\201\019\202\019\203\019\204\019\205\019\206\019\207\019\208\019\209\019\210\019\211\019\212\019\213\019\214\019\215\019\216\019\217\019\218\019\219\019\220\019\221\019\222\019\223\019\224\019\225\019\227\019\228\019\229\019\230\019\231\019\232\019\233\019\234\019\235\019\236\019\240\019\241\019\242\019\243\019\244\019\246\019\247\019\248\019\249\019\251\019\252\019\253\019\254\020\000\020\001\020\002\020\003\020\004\020\012\020\018\020\021\020\022\020\023\020\024\020\025\020\026\020\027\020\028\020\029\020\030\020\031\020 \020!\020\"\020#\020$\020%\020&\020'\020(\020)\020+\020-\020.\020/\0200\0201\0202\0203\0204\0205\0206\0207\0209\020;\020=\020?\020@\020A\020B\020C\020D\020E\020F\020I\020K\020L\020N\020O\020P\020Q\020R\020T\020V\020X\020Y\020Z\020[\020\\\020]\020^\020a\020d\020e\020h\020k\020m\020n\020o\020p\020r\020s\020t\020u\020v\020w\020x\020y\020z\020~\020\128\020\129\020\131\020\132\020\133\020\134\020\135\020\136\020\139\020\142\020\144\020\145\020\146\020\147\020\149\020\150\020\151\020\152\020\153\020\154\020\155\020\156\020\157\020\158\020\159\020\161\020\162\020\163\020\165\020\169\020\170\020\171\020\172\020\173\020\174\020\175\020\177\020\178\020\179\020\181\020\182\020\183\020\185\020\186\020\187\020\188\020\189\020\191\020\192\020\194\020\195\020\196\020\198\020\200\020\201\020\203\020\204\020\205\020\207\020\208\020\209\020\211\020\212\020\214\020\215\020\217\020\218\020\219\020\220\020\221\020\224\020\225\020\226\020\227\020\228\020\230\020\231\020\232\020\233\020\234\020\235\020\237\020\238\020\239\020\240\020\241\020\242\020\243\020\244\020\245\020\246\020\247\020\248\020\249\020\250\020\252\020\253\020\254\020\255\021\001\021\002\021\003\021\004\021\005\021\006\021\007\021\b\021\t\021\n\021\011\021\012\021\r\021\014\021\015\021\016\021\017\021\018\021\019\021\020\021\021\021\022\021\023\021\025\021\026\021\027\021\028\021\029\021\030\021\031\021 \021!\021\"\021#\021$\021%\021(\021)\021*\021+\021,\021-\021.\021/\0210\0211\0212\0216\021:\021;\021B\021C\021D\021F\021G\021H\021I\021J\021K\021L\021N\021O\021P\021Q\021R\021S\021T\021V\021X\021Y\021Z\021[\021^\021_\021`\021a\021b\021c\021d\021e\021g\021h\021i\021j\021l\021n\021o\021q\021r\021s\021t\021u\021x\021y\021z\021{\021~\021\129\021\131\021\133\021\134\021\135\021\140\021\142\021\143\021\144\021\145\021\146\021\147\021\148\021\149\021\152\021\154\021\155\021\156\021\157\021\158\021\160\021\163\021\164\021\166\021\167\021\168\021\169\021\170\021\172\021\173\021\174\021\175\021\176\021\178\021\179\021\180\021\181\021\182\021\184\021\185\021\186\021\187\021\188\021\191\021\194\021\195\021\196\021\198\021\199\021\200\021\201\021\202\021\204\021\205\021\206\021\207\021\211\021\212\021\213\021\214\021\215\021\216\021\217\021\218\021\219\021\220\021\221\021\222\021\223\021\224\021\225\021\226\021\227\021\228\021\229\021\232\021\233\021\234\021\235\021\236\021\241\021\245\021\247\021\248\021\249\021\250\021\251\021\252\021\253\021\254\021\255\022\000\022\001\022\002\022\003\022\004\022\005\022\006\022\b\022\t\022\n\022\011\022\012\022\r\022\014\022\015\022\018\022\019\022\020\022\021\022\023\022\024\022\025\022\026\022\030\022\031\022 \022!\022%\022&\022'\022(\022)\022*\022+\0221\0222\0223\0224\0225\0226\0227\0229\022;\022<\022C\022J\022K\022L\022M\022N\022O\022R\022S\022T\022U\022V\022W\022X\022Y\022Z\022[\022\\\022]\022^\022`\022a\022b\022c\022d\022e\022f\022g\022h\022i\022j\022k\022l\022m\022n\022o")) and nullable = - "\000\000\016)\001\000@\000\001\014\016\000\001\255\128\192\000\000?\255\128\000@\130\016\000\012\000\000" + "\000\000\016)\001\000@\000\000\135\b\000\000\255\224\024\000\000\031\255\192\000 @ \128\0000 \000" and first = - (133, "3\248H1b\171\1273=\001P}\200\160\001\199\001\159\194A\139\021[\249\153\232\n\131\238E\000\0148\000 \000\000\000\000\006\000\000\000\000\000\000\000\000\000\000\003\016\128 @\0020$Z\000 \n\128\000\001\004\000\b\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000@\b\b\000\004\012\b\000\000\000@\000\000\000\000\000\006\002\000@\000\000@@\000\000\002\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\000`\000\007\001\000\006\023\b\000\004\000\000\000\000\000\000\001\016\000\000\000\000 \000@\000\000\002\000\000\000\000\000\b\128\000\000\000\001\128\002\000\000\000\016\000\000\000\000\001 \004\016\001\004\000\016\128\000\128\000d\000\000\128\000\207\225 \197\138\173\252\204\244\005\001\247\"\128\007\028\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000@\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000 \000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\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\b\004\000 \000\000\000\000\000\000\002\000\002\000\000\000\000\000`\000\000\000\000\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\016\000\000\000\000\000\000\000\000\000\001\159\194A\139\021[\249\153\232\n\131\238E\000\0148\000\000\000\000H\000@\000\000\002\000\000\000\000\000\001\000\002\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\146\000\017\000\000\000\128\000\000\000\000\000@\000\128\000\004\144\000\128\000\000\004\000\000\000\000\000\002\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\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\018\000\000\012\000\000\192\000\000\194\225\000\000\128\000\000\000\000\000\012\254\018\012X\170\223\204\207@T\031r(\000q\192\000\000\000\000\000\000\000\000\000\000 \000\000\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\128\000\000\000\000\000\000\000\000\000\000\t\000\000\128\b \020\132\000\004\000\003\000\000\004\000\006\127\t\006,Uo\230g\160(\015\184\020\0008\224\001\138@\020$\001\024\018+\000\016\005 \000\000\130\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\023\183d@\130\254*@\0010p:q\193`Ph\003\016\128 @\002 $R\000 \n\000\000\001\004\000\024\132\001\002\000\017\129\"\144\001\000P\000\000\b \000\196 \b\128P\012\t\028\128\000\002\128P\000c\000\000\000\000\000\000\000\000\b\160\000\000\000\000\000\000\000\000\000\b\000\004\000 \000\000 \000\000\128\000\000\016\000\002@\000 \002\b\000!\000\001\000\000\192\000\001\000\000\018\000A\000\016@\001\b\000\b\000\006\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000cp\128\"\193F\254$z\000\128\250\001@\001\142\000\b\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\196 \b\016\000\140\t\022\128\b\002\160\000\000A\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\0067\b\002,\020o\226G\160\b\015\160\020\000\024\224\001\128\000\028\004\000\024\\ \000\016\000\000\000\000\002\000\012\000\000\192\000\000\194\225\000\000\128\000\000\000\000\000\012n\016\004X(\223\196\143@\016\031@(\0001\192\003\000\0008\b\0000\184@\000 \000\000\000\000\000\000\024\000\001\128\000\001\133\194\000\001\000\000\000\000\000\000\000\128\000\004\144\000\128\000\000\004\000\000\000\000\000\002\000\006\000\000p\016\000ap\128\000@\000\000\000\000\000\0000\000\003\128\128\003\011\132\000\002\000\000\000\000\000@\000@\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\012\000\000\224 \000\194\225\000\000\128\000\000\000\000\000\000b\016\004\b\000F\004\139@\004\001P\000\000\"\128\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\197 \n\130P\012\t\029\128\000\002\128P\000c\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\136\000\000\000\000\016\000 \000\000\001\000\000\000\b\000\004@\000\000\000\000\128\001\000\000\000\b\000\000\000@\000\"\000\000\000\000\004\000\b\000\000\000@\000\000\002\000\003\016\128\"\001@0$r\000\000\n\001@\001\140\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\012\000\000\224 \000\194\225\000\000\128\000\000\000\000\000\000`\000\007\001\000\006\023\b\000\004\000\000\000\000\000\000g\240\144j\197V\254fz\002\128\251\129@\007\142\000\016\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\196 \b\016\000\140\t\022\128\b\002\128\000\000A\000\006!\000@\128\004`H\180\000@\020\000\000\002\b\0001\b\002\004\000#\002E\160\002\000\160\000\000\016@\001\136@\016 \001\024\018-\000\016\005@\000\000\130\000\012B\000\129\000\b\192\145h\000\128*\000\000\004\016\000 \000\000\000\000\006\000\000\000\000\000\000\000\000\000\000\003\016\128 @\0020$Z\000 \n\128\000\001\004\000\b\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000@\b\b\000\004\012\b\000\000\000@\000\000\000\000\000\006\002\000@\000\000@@\000\000\002\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\141\194\000\139\005\027\248\145\232\002\003\232\005\000\0068\000`\000\007\001\000\006\023\b\000\004\000\000\000\000\000\000\001\016\000\000\000\000 \000@\000\000\002\000\000\000\000\000\b\128\000\000\000\001\128\002\000\000\000\016\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\016\016\000\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\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\016\000\000\000\000\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\016\000\001\000\015\192\024\018\000\001\241\b\001\002\000@\162\192\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\024\128\001\224@\001\133\194\128\001\000\016\001\000\000\128\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\004\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\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\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000@\b\b\000\004\012\b\000\000\000@\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\128\128\016\000\000\016\016\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\004\000\000\000\000\000\b\000\000\128\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\012\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\016\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\192\000\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\016\000\000\000\000\000\000\000\000\000\000@\000\000 \000\000\128\004\000\000\000\000\000\000\000@\000\192\000\012\000\000\012.\016\000\b\000\000\b\000\000\000\006!\000@\128\004`H\180\000@\021\000\000\002\b\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\144\002\b\000\130\001H@\000D\0000\000\000@\000\004\128\000@\004\016\nB\000\002\000\001\128\000\002\000\000 \000\002\000\000\b\002\016\012\000\000\000\000\b\000\000\001\000\000\016\000\000@\016\128 \000\000\000\000@\000\000\t\000 \128\b \020\132\000\004\000\003\000\000\004\000\000H\001\004\000A\000\004 \000 \000\024\000\000 \000\000\000\000\000\000\000\000\000\128\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\b\000\000\000\000\000\000\000\000\128\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\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \012B\000\129\000\b\192\145h\000\128(\000\000\004\016\000b\016\004\b\000F\004\139@\004\001@\000\000 \128\003\016\128 @\0020$Z\000 \n\128\000\001\004\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\006!\000@\128\004`H\180\000@\020\000\000\002\b\0001\b\002\004\000#\002E\160\002\000\160\000\000\016@\001\138@\020$\001\024\018+\000\016\005\000\000\000\130\000\012R\000\168%\000\192\145\216\000\000(\005\000\0060\000 \000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@ \000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\004\000\000\000\000\000\000\000\000\000\002@\b \002\b\000!\000\001\000\000\200\000\001\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\012\254\018\012X\170\223\204\207@P\031r(\000q\192\001\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\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\128\000\000\004\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\002\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\003\000\0008\b\0000\184@\000 \000\000\000\000\000\000\024\164\001B@Q\129\"\176\001\000P\000\000( \000\197 \n\018\000\140\t\021\128\b\002\144\000\tA\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\136\000\000\000\000\016\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\004\000\000\000\004\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\027\132\001\022\n7\241#\208\004\007\208\n\000\012p\000\002\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\006\000\000p\016\000ap\128\000@\000\000\000\000\000\000\017\000\000\000\000\002\000\004\000\000\000 \000\000\001\000\001\128\000\024\000\000\024\\(\000\016\000\000\000\000\000\000\012\000\000\224 \000\194\225\000\000\128\000\000\000\000\000\000\"\000\000\000\000\004\000\b\000\000\000@\000\000\000\000\001\016\000\000\000\000 \000@\000\000\002\000\000\000\000\000\000\128\000\000\000\001\000\002\000\000\000\016\000\000\000\000\000\000 \000\000\000\000\000\000\128\000\002\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\001\128\000\028\004\128\025\\ \000\016\000\000\000\000\000\000\004\000\000\000\004\000\192\001\000\000\000\000\000\000\000\000\000 \000\004\000 \002D\b\000\000\000\000\000\000\000\000\004\000\000@\000\001\000B\000\128\000\000\000\001\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\b\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\0001H\002\132\128#\002E`\002\000\160\000\000\016@\001\138@\020$\001\024\018+\000\016\005 \000\002\130\000\016\000\001\000\000\004\001\b\006\000\000\000\000\004\000\000\000 \000\004\000 \006D\b\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\005\237\217\016 \191\138\144\000L\028\014\156pX\020\026\000\192\000\012\000\000\012.\016\000\b\000\000\000\000\000\000\002 \000\000\000\000`\000\128\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\001\128\000\028\004\000\024\\ \000\016\000\000\000\000\000\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\000\000\000") + (127, "'\225 \197\138\173\2433\208\021\007\242(\000q\192O\194A\139\021[\230g\160*\015\228P\000\227\128\004\000\000\000\000\003\000\000\000\000\000\000\000\000\000\000\025\b\002\004\000&\t\022\128\b\006\128\000\001\004\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000 \b\b\000\004\024 \000\000\001\000\000\000\000\000\000\192\128\016\000\000 @\000\000\002\000\000\000\000\000\000\128\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\000F\194\000\139\005\027\226G\160\b\015\128P\000c\128\012\000\001\192@\003\023\b\000\004\000\000\000\000\000\000\t\000\000\000\000\004\000\016\000\000\002\000\000\000\000\000\018\000\000\000\000\012\000 \000\000\004\000\000\000\000\000\144\004\016\001\004\000B\000\002\000\006@\000\b\000\t\248H1b\171|\204\244\005\001\252\138\000\028p\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\128\000\000\000 \000\000\000\000\000\000\000\000\000\000\016\000\000\016\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\001\000\000\000\000\b\b\000\128\000\000\000\000\000\000 \000@\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000O\194A\139\021[\230g\160*\015\228P\000\227\128\000\000\000\018\000\016\000\000\002\000\000\000\000\000\004\000\016\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\002H\000H\000\000\b\000\000\000\000\000\016\000@\000\004\144\000\128\000\000\016\000\000\000\000\000 \000@\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128\000\006\000\000\192\000\001\139\132\000\002\000\000\000\000\000\000\159\132\131\022*\183\204\207@T\031\200\160\001\199\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\001\128\000\000\000\000\000\000\000\000\000\001 \000 \002\b\004\132\000\004\000\012\000\000\016\000\019\240\144b\197V\249\153\232\n\003\248\020\0008\224\003)\000P\144\004\193\"\176\001\000\200\000\000 \128\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\001\247\217\016 \191\141@\0010p=\199\005\129A\160\025\b\002\004\000$\t\020\128\b\006\000\000\001\004\0002\016\004\b\000L\018)\000\016\012\000\000\002\b\000d \b\128P\024$r\000\000\024\005\000\0060\000\000\000\000\000\000\000\b\160\000\000\000\000\000\000\000\000\000\128\000@\002\000\000\b\000\000@\000\000\016\000\004\128\000\128\b \002\016\000\016\0000\000\000@\000\t\000A\000\016@\004 \000 \000`\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\001\027\b\002,\020o\137\030\128 >\001@\001\142\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000d \b\016\000\152$Z\000 \026\000\000\004\016\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\017\176\128\"\193F\248\145\232\002\003\224\020\000\024\224\003\000\000p\016\000\197\194\000\001\000\000\000\000\000\128\006\000\000\192\000\001\139\132\000\002\000\000\000\000\000\000\141\132\001\022\n7\196\143@\016\031\000\160\000\199\000\024\000\003\128\128\006.\016\000\b\000\000\000\000\000\0000\000\006\000\000\012\\ \000\016\000\000\000\000\000\000@\000\004\144\000\128\000\000\016\000\000\000\000\000 \000\192\000\028\004\0001p\128\000@\000\000\000\000\000\001\128\0008\b\000b\225\000\000\128\000\000\000\000@\000\128\000\000\000 \000\000\000\000\000\000\000\000\000\000\006\000\000\224 \001\139\132\000\002\000\000\000\000\000\000\012\132\001\002\000\019\004\139@\004\003@\000\000\138\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\b\000e \n\130P\024$v\000\000\024\005\000\0060\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\001\148\128(H\002`\145X\000\128`\000\000\016@\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\002@\000\000\000\001\000\004\000\000\000\128\000\000\004\000\004\128\000\000\000\002\000\b\000\000\001\000\000\000\b\000\t\000\000\000\000\004\000\016\000\000\002\000\000\000\016\0002\016\004@(\012\0189\000\000\012\002\128\003\024\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\012\000\001\192@\003\023\b\000\004\000\000\000\000\000\000\024\000\003\128\128\006.\016\000\b\000\000\000\000\000\002~\018\rX\170\2233=\001@\127\002\128\015\028\000@\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\200@\016 \0010H\180\000@0\000\000\b \001\144\128 @\002`\145h\000\128`\000\000\016@\003!\000@\128\004\193\"\208\001\000\192\000\000 \128\006B\000\129\000\t\130E\160\002\001\160\000\000A\000\012\132\001\002\000\019\004\139@\004\003@\000\000\130\000\b\000\000\000\000\006\000\000\000\000\000\000\000\000\000\0002\016\004\b\000L\018-\000\016\r\000\000\002\b\000 \000\000\000\000\b\000\000\000\000\000\000\000\000\000\000@\016\016\000\b0@\000\000\002\000\000\000\000\000\001\129\000 \000\000@\128\000\000\004\000\000\000\000\000\001\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\141\132\001\022\n7\196\143@\016\031\000\160\000\199\000\024\000\003\128\128\006.\016\000\b\000\000\000\000\000\000\018\000\000\000\000\b\000 \000\000\004\000\000\000\000\000$\000\000\000\000\024\000@\000\000\b\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\b\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\004\000?\000a \000\031\016\128@\128\016(\176\000\000\000\000\128\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\001\000\000\000\000\000\000\000\000\000\001\144\000<\b\000b\225@\000\128 \002\000\001\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\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\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\001\000@@\000 \193\000\000\000\b\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\024\016\002\000\000\004\b\000\000\000@\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\016\000\000\000\000\001\000\000\016\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\192\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\004\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\012\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\016\000\000\000\000\000\000\000\000\000\004\000\000\004\000\000 \002\000\000\000\000\000\000\000\128\003\000\000`\000\000\197\194\000\001\000\000\004\000\000\000\006B\000\129\000\t\130E\160\002\001\160\000\000A\000\004\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000$\001\004\000A\000\144\128\000\136\001\128\000\002\000\000H\000\b\000\130\001!\000\001\000\003\000\000\004\000\000\128\000\016\000\000@B\001\128\000\000\000\004\000\000\001\000\000 \000\000\128\132\001\000\000\000\000\b\000\000\002@\016@\004\016\t\b\000\b\000\024\000\000 \000\004\128 \128\b \002\016\000\016\0000\000\000@\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\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\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\012\132\001\002\000\019\004\139@\004\003\000\000\000\130\000\025\b\002\004\000&\t\022\128\b\006\000\000\001\004\0002\016\004\b\000L\018-\000\016\r\000\000\002\b\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\001\144\128 @\002`\145h\000\128`\000\000\016@\003!\000@\128\004\193\"\208\001\000\192\000\000 \128\006R\000\161 \t\130E`\002\001\128\000\000A\000\012\164\001PJ\003\004\142\192\000\003\000\160\000\198\000\b\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\002\000\000\000\000\000\000\000\000\000\t\000A\000\016@\004 \000 \000d\000\000\128\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\001?\t\006,Uo\153\158\128\160?\145@\003\142\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\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\002\000\000\000\000\000\b\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\004l \b\176Q\190$z\000\128\248\005\000\0068\000\202@\020$\0010H\172\000@0\000\000\b \001\148\128(H\002`\145X\000\128`\000\000\016@#a\000E\130\141\241#\208\004\007\192(\0001\192F\194\000\139\005\027\226G\160\b\015\128P\000c\128\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\004\000\000\000\016\000\000\000\000\000\000\000\000\000$\000\000\000\000\016\000@\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000 \000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\002\003\b\000\000\000\000\000\000\000\000\000\000\002\000\000\004.\016\000\000\000\000\000\000\000\0000\000\007\001\000\012\\ \000\016\000\000\000\000\000\000$\000\000\000\000\016\000@\000\000\b\000\000\000@\000\192\000\024\000\0001p\160\000@\000\000\000\000\000\001\128\0008\b\000b\225\000\000\128\000\000\000\000\000\001 \000\000\000\000\128\002\000\000\000@\000\000\000\000\002@\000\000\000\001\000\004\000\000\000\128\000\000\000\000\000\128\000\000\000\002\000\b\000\000\001\000\000\000\000\000\000\b\000\000\000\000\000\000\128\000\004\000\000\001\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\192\000\028\004\1285p\128\000@\000\000\000\000\000\000\128\000\000\001\000`\001\000\000\000\000\000\000\000\000\001\000\000@\002\000Q\002\000\000\000\000\000\000\000\000\b\000\001\000\000\004\004 \b\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\004\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000e \n\018\000\152$V\000 \024\000\000\004\016\000\202@\020$\0010H\172\000@2\000\000( \002\000\000@\000\001\001\b\006\000\000\000\000\016\000\000\001\000\000@\002\000\209\002\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\159\132\131V*\183\204\207@P\031\192\160\003\199\003\239\178 A\127\026\128\002`\224{\142\011\002\131@0\000\006\000\000\012\\ \000\016\000\000\000\000\000\000$\000\000\000\000\024\000@\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\001\128\0008\b\000b\225\000\000\128\000\000\000\000\000\000\000\000\001\128\000\000\000\000\000\000\000\000\000\000\000") end) (ET) (TI) @@ -46235,59 +54623,59 @@ end let use_file = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry `Legacy 1844 lexer lexbuf) : (Parsetree.toplevel_phrase list)) + (Obj.magic (MenhirInterpreter.entry `Legacy 1991 lexer lexbuf) : (Parsetree.toplevel_phrase list)) and toplevel_phrase = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry `Legacy 1824 lexer lexbuf) : (Parsetree.toplevel_phrase)) + (Obj.magic (MenhirInterpreter.entry `Legacy 1971 lexer lexbuf) : (Parsetree.toplevel_phrase)) and parse_val_longident = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry `Legacy 1818 lexer lexbuf) : (Longident.t)) + (Obj.magic (MenhirInterpreter.entry `Legacy 1965 lexer lexbuf) : (Longident.t)) and parse_pattern = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry `Legacy 1814 lexer lexbuf) : (Parsetree.pattern)) + (Obj.magic (MenhirInterpreter.entry `Legacy 1961 lexer lexbuf) : (Parsetree.pattern)) and parse_mty_longident = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry `Legacy 1810 lexer lexbuf) : (Longident.t)) + (Obj.magic (MenhirInterpreter.entry `Legacy 1957 lexer lexbuf) : (Longident.t)) and parse_module_type = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry `Legacy 1806 lexer lexbuf) : (Parsetree.module_type)) + (Obj.magic (MenhirInterpreter.entry `Legacy 1953 lexer lexbuf) : (Parsetree.module_type)) and parse_module_expr = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry `Legacy 1802 lexer lexbuf) : (Parsetree.module_expr)) + (Obj.magic (MenhirInterpreter.entry `Legacy 1949 lexer lexbuf) : (Parsetree.module_expr)) and parse_mod_longident = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry `Legacy 1798 lexer lexbuf) : (Longident.t)) + (Obj.magic (MenhirInterpreter.entry `Legacy 1945 lexer lexbuf) : (Longident.t)) and parse_mod_ext_longident = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry `Legacy 1794 lexer lexbuf) : (Longident.t)) + (Obj.magic (MenhirInterpreter.entry `Legacy 1941 lexer lexbuf) : (Longident.t)) and parse_expression = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry `Legacy 1790 lexer lexbuf) : (Parsetree.expression)) + (Obj.magic (MenhirInterpreter.entry `Legacy 1937 lexer lexbuf) : (Parsetree.expression)) and parse_core_type = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry `Legacy 1786 lexer lexbuf) : (Parsetree.core_type)) + (Obj.magic (MenhirInterpreter.entry `Legacy 1933 lexer lexbuf) : (Parsetree.core_type)) and parse_constr_longident = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry `Legacy 1782 lexer lexbuf) : (Longident.t)) + (Obj.magic (MenhirInterpreter.entry `Legacy 1929 lexer lexbuf) : (Longident.t)) and parse_any_longident = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry `Legacy 1764 lexer lexbuf) : (Longident.t)) + (Obj.magic (MenhirInterpreter.entry `Legacy 1911 lexer lexbuf) : (Longident.t)) and interface = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry `Legacy 1760 lexer lexbuf) : (Parsetree.signature)) + (Obj.magic (MenhirInterpreter.entry `Legacy 1907 lexer lexbuf) : (Parsetree.signature)) and implementation = fun lexer lexbuf -> @@ -46297,59 +54685,59 @@ module Incremental = struct let use_file = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1844 initial_position) : (Parsetree.toplevel_phrase list) MenhirInterpreter.checkpoint) + (Obj.magic (MenhirInterpreter.start 1991 initial_position) : (Parsetree.toplevel_phrase list) MenhirInterpreter.checkpoint) and toplevel_phrase = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1824 initial_position) : (Parsetree.toplevel_phrase) MenhirInterpreter.checkpoint) + (Obj.magic (MenhirInterpreter.start 1971 initial_position) : (Parsetree.toplevel_phrase) MenhirInterpreter.checkpoint) and parse_val_longident = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1818 initial_position) : (Longident.t) MenhirInterpreter.checkpoint) + (Obj.magic (MenhirInterpreter.start 1965 initial_position) : (Longident.t) MenhirInterpreter.checkpoint) and parse_pattern = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1814 initial_position) : (Parsetree.pattern) MenhirInterpreter.checkpoint) + (Obj.magic (MenhirInterpreter.start 1961 initial_position) : (Parsetree.pattern) MenhirInterpreter.checkpoint) and parse_mty_longident = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1810 initial_position) : (Longident.t) MenhirInterpreter.checkpoint) + (Obj.magic (MenhirInterpreter.start 1957 initial_position) : (Longident.t) MenhirInterpreter.checkpoint) and parse_module_type = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1806 initial_position) : (Parsetree.module_type) MenhirInterpreter.checkpoint) + (Obj.magic (MenhirInterpreter.start 1953 initial_position) : (Parsetree.module_type) MenhirInterpreter.checkpoint) and parse_module_expr = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1802 initial_position) : (Parsetree.module_expr) MenhirInterpreter.checkpoint) + (Obj.magic (MenhirInterpreter.start 1949 initial_position) : (Parsetree.module_expr) MenhirInterpreter.checkpoint) and parse_mod_longident = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1798 initial_position) : (Longident.t) MenhirInterpreter.checkpoint) + (Obj.magic (MenhirInterpreter.start 1945 initial_position) : (Longident.t) MenhirInterpreter.checkpoint) and parse_mod_ext_longident = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1794 initial_position) : (Longident.t) MenhirInterpreter.checkpoint) + (Obj.magic (MenhirInterpreter.start 1941 initial_position) : (Longident.t) MenhirInterpreter.checkpoint) and parse_expression = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1790 initial_position) : (Parsetree.expression) MenhirInterpreter.checkpoint) + (Obj.magic (MenhirInterpreter.start 1937 initial_position) : (Parsetree.expression) MenhirInterpreter.checkpoint) and parse_core_type = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1786 initial_position) : (Parsetree.core_type) MenhirInterpreter.checkpoint) + (Obj.magic (MenhirInterpreter.start 1933 initial_position) : (Parsetree.core_type) MenhirInterpreter.checkpoint) and parse_constr_longident = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1782 initial_position) : (Longident.t) MenhirInterpreter.checkpoint) + (Obj.magic (MenhirInterpreter.start 1929 initial_position) : (Longident.t) MenhirInterpreter.checkpoint) and parse_any_longident = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1764 initial_position) : (Longident.t) MenhirInterpreter.checkpoint) + (Obj.magic (MenhirInterpreter.start 1911 initial_position) : (Longident.t) MenhirInterpreter.checkpoint) and interface = fun initial_position -> - (Obj.magic (MenhirInterpreter.start 1760 initial_position) : (Parsetree.signature) MenhirInterpreter.checkpoint) + (Obj.magic (MenhirInterpreter.start 1907 initial_position) : (Parsetree.signature) MenhirInterpreter.checkpoint) and implementation = fun initial_position -> @@ -46357,12 +54745,12 @@ module Incremental = struct end -# 4118 "src/ocaml/preprocess/parser_raw.mly" +# 4273 "src/ocaml/preprocess/parser_raw.mly" -# 46364 "src/ocaml/preprocess/parser_raw.ml" +# 54752 "src/ocaml/preprocess/parser_raw.ml" # 269 "" -# 46369 "src/ocaml/preprocess/parser_raw.ml" +# 54757 "src/ocaml/preprocess/parser_raw.ml" diff --git a/src/ocaml/preprocess/parser_raw.mli b/src/ocaml/preprocess/parser_raw.mli index 8813c36a87..07068589e7 100644 --- a/src/ocaml/preprocess/parser_raw.mli +++ b/src/ocaml/preprocess/parser_raw.mli @@ -3,7 +3,6 @@ type token = | WITH - | WHILE_LWT | WHILE | WHEN | VIRTUAL @@ -11,7 +10,6 @@ type token = | UNDERSCORE | UIDENT of (string) | TYPE - | TRY_LWT | TRY | TRUE | TO @@ -50,11 +48,9 @@ type token = | MINUSDOT | MINUS | METHOD - | MATCH_LWT | MATCH | LPAREN | LIDENT of (string) - | LET_LWT | LETOP of (string) | LET | LESSMINUS @@ -92,10 +88,8 @@ type token = | FUNCTOR | FUNCTION | FUN - | FOR_LWT | FOR | FLOAT of (string * char option) - | FINALLY_LWT | FALSE | EXTERNAL | EXCEPTION @@ -183,7 +177,6 @@ module MenhirInterpreter : sig type _ terminal = | T_error : unit terminal | T_WITH : unit terminal - | T_WHILE_LWT : unit terminal | T_WHILE : unit terminal | T_WHEN : unit terminal | T_VIRTUAL : unit terminal @@ -191,7 +184,6 @@ module MenhirInterpreter : sig | T_UNDERSCORE : unit terminal | T_UIDENT : (string) terminal | T_TYPE : unit terminal - | T_TRY_LWT : unit terminal | T_TRY : unit terminal | T_TRUE : unit terminal | T_TO : unit terminal @@ -230,11 +222,9 @@ module MenhirInterpreter : sig | T_MINUSDOT : unit terminal | T_MINUS : unit terminal | T_METHOD : unit terminal - | T_MATCH_LWT : unit terminal | T_MATCH : unit terminal | T_LPAREN : unit terminal | T_LIDENT : (string) terminal - | T_LET_LWT : unit terminal | T_LETOP : (string) terminal | T_LET : unit terminal | T_LESSMINUS : unit terminal @@ -272,10 +262,8 @@ module MenhirInterpreter : sig | T_FUNCTOR : unit terminal | T_FUNCTION : unit terminal | T_FUN : unit terminal - | T_FOR_LWT : unit terminal | T_FOR : unit terminal | T_FLOAT : (string * char option) terminal - | T_FINALLY_LWT : unit terminal | T_FALSE : unit terminal | T_EXTERNAL : unit terminal | T_EXCEPTION : unit terminal @@ -336,7 +324,7 @@ module MenhirInterpreter : sig | N_type_parameter : (Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) nonterminal | N_type_longident : (Longident.t) nonterminal | N_type_kind : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) nonterminal - | N_type_constraint : (Parsetree.core_type option * Parsetree.core_type option) nonterminal + | N_type_constraint : (Parsetree.type_constraint) nonterminal | N_tuple_type : (Parsetree.core_type) nonterminal | N_toplevel_phrase : (Parsetree.toplevel_phrase) nonterminal | N_toplevel_directive : (Parsetree.toplevel_phrase) nonterminal @@ -375,6 +363,7 @@ module MenhirInterpreter : sig | N_reversed_nonempty_llist_name_tag_ : (string list) nonterminal | N_reversed_nonempty_llist_labeled_simple_expr_ : ((Asttypes.arg_label * Parsetree.expression) list) nonterminal | N_reversed_nonempty_llist_functor_arg_ : ((Lexing.position * Parsetree.functor_parameter) list) nonterminal + | N_reversed_nonempty_concat_fun_param_as_list_ : (Parsetree.function_param list) nonterminal | N_reversed_llist_preceded_CONSTRAINT_constrain__ : ((Parsetree.core_type * Parsetree.core_type * Location.t) list) nonterminal | N_reversed_bar_llist_extension_constructor_declaration_ : (Parsetree.extension_constructor list) nonterminal | N_reversed_bar_llist_extension_constructor_ : (Parsetree.extension_constructor list) nonterminal @@ -408,12 +397,13 @@ module MenhirInterpreter : sig | N_parse_any_longident : (Longident.t) nonterminal | N_paren_module_expr : (Parsetree.module_expr) nonterminal | N_optlabel : (string) nonterminal - | N_option_type_constraint_ : ((Parsetree.core_type option * Parsetree.core_type option) option) nonterminal + | N_option_type_constraint_ : (Parsetree.type_constraint option) nonterminal | N_option_preceded_EQUAL_seq_expr__ : (Parsetree.expression option) nonterminal | N_option_preceded_EQUAL_pattern__ : (Parsetree.pattern option) nonterminal | N_option_preceded_EQUAL_module_type__ : (Parsetree.module_type option) nonterminal | N_option_preceded_EQUAL_expr__ : (Parsetree.expression option) nonterminal | N_option_preceded_COLON_core_type__ : (Parsetree.core_type option) nonterminal + | N_option_preceded_COLON_atomic_type__ : (Parsetree.core_type option) nonterminal | N_option_preceded_AS_mkrhs_LIDENT___ : (string Location.loc option) nonterminal | N_option_SEMI_ : (unit option) nonterminal | N_option_BAR_ : (unit option) nonterminal @@ -421,6 +411,7 @@ module MenhirInterpreter : sig | N_operator : (string) nonterminal | N_open_description : (Longident.t Location.loc Parsetree.open_infos * string Location.loc option) nonterminal | N_open_declaration : (Parsetree.module_expr Parsetree.open_infos * string Location.loc option) nonterminal + | N_object_type : (Parsetree.core_type) nonterminal | N_nonempty_type_kind : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) nonterminal | N_nonempty_list_raw_string_ : (string list) nonterminal | N_nonempty_list_mkrhs_LIDENT__ : (string Location.loc list) nonterminal @@ -442,15 +433,13 @@ module MenhirInterpreter : sig | N_mk_longident_mod_longident_UIDENT_ : (Longident.t) nonterminal | N_mk_longident_mod_longident_LIDENT_ : (Longident.t) nonterminal | N_mk_longident_mod_ext_longident_ident_ : (Longident.t) nonterminal - | N_mk_longident_mod_ext_longident___anonymous_41_ : (Longident.t) nonterminal + | N_mk_longident_mod_ext_longident___anonymous_43_ : (Longident.t) nonterminal | N_mk_longident_mod_ext_longident_UIDENT_ : (Longident.t) nonterminal | N_mk_longident_mod_ext_longident_LIDENT_ : (Longident.t) nonterminal | N_method_ : ((string Location.loc * Asttypes.private_flag * Parsetree.class_field_kind) * Parsetree.attributes) nonterminal | N_meth_list : (Parsetree.object_field list * Asttypes.closed_flag) nonterminal | N_match_case : (Parsetree.case) nonterminal - | N_lwt_bindings : (Ast_helper.let_bindings) nonterminal - | N_lwt_binding : (Ast_helper.let_bindings) nonterminal | N_listx_SEMI_record_pat_field_UNDERSCORE_ : ((Longident.t Location.loc * Parsetree.pattern) list * unit option) nonterminal | N_list_use_file_element_ : (Parsetree.toplevel_phrase list list) nonterminal | N_list_text_str_structure_item__ : (Parsetree.structure_item list list) nonterminal @@ -472,8 +461,10 @@ module MenhirInterpreter : sig | N_let_pattern : (Parsetree.pattern) nonterminal | N_let_bindings_no_ext_ : (Ast_helper.let_bindings) nonterminal | N_let_bindings_ext_ : (Ast_helper.let_bindings) nonterminal - | N_let_binding_body_no_punning : (Parsetree.pattern * Parsetree.expression) nonterminal - | N_let_binding_body : (Parsetree.pattern * Parsetree.expression * bool) nonterminal + | N_let_binding_body_no_punning : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option) nonterminal + | N_let_binding_body : (Parsetree.pattern * Parsetree.expression * + Parsetree.value_constraint option * bool) nonterminal | N_labeled_simple_pattern : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) nonterminal | N_labeled_simple_expr : (Asttypes.arg_label * Parsetree.expression) nonterminal | N_label_longident : (Longident.t) nonterminal @@ -501,16 +492,21 @@ module MenhirInterpreter : sig | N_functor_args : ((Lexing.position * Parsetree.functor_parameter) list) nonterminal | N_functor_arg : (Lexing.position * Parsetree.functor_parameter) nonterminal | N_function_type : (Parsetree.core_type) nonterminal - | N_fun_def : (Parsetree.expression) nonterminal - | N_fun_binding : (Parsetree.expression) nonterminal + | N_fun_seq_expr : (Parsetree.expression) nonterminal + | N_fun_params : (Parsetree.function_param list) nonterminal + | N_fun_param_as_list : (Parsetree.function_param list) nonterminal + | N_fun_expr : (Parsetree.expression) nonterminal + | N_fun_body : (Parsetree.function_body) nonterminal | N_formal_class_parameters : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) nonterminal | N_floating_attribute : (Parsetree.attribute) nonterminal + | N_extension_type : (Parsetree.core_type) nonterminal | N_extension_constructor_rebind_epsilon_ : (Parsetree.extension_constructor) nonterminal | N_extension_constructor_rebind_BAR_ : (Parsetree.extension_constructor) nonterminal | N_extension : (Parsetree.extension) nonterminal | N_ext : (string Location.loc option) nonterminal - | N_expr : (Parsetree.expression) nonterminal | N_direction_flag : (Asttypes.direction_flag) nonterminal + | N_delimited_type_supporting_local_open : (Parsetree.core_type) nonterminal + | N_delimited_type : (Parsetree.core_type) nonterminal | N_core_type : (Parsetree.core_type) nonterminal | N_constructor_declarations : (Parsetree.constructor_declaration list) nonterminal | N_constructor_arguments : (Parsetree.constructor_arguments) nonterminal @@ -533,6 +529,7 @@ module MenhirInterpreter : sig | N_class_field : (Parsetree.class_field) nonterminal | N_class_expr : (Parsetree.class_expr) nonterminal | N_attribute : (Parsetree.attribute) nonterminal + | N_attr_payload : (Parsetree.payload) nonterminal | N_attr_id : (string Location.loc) nonterminal | N_atomic_type : (Parsetree.core_type) nonterminal | N_any_longident : (Longident.t) nonterminal diff --git a/src/ocaml/preprocess/parser_raw.mly b/src/ocaml/preprocess/parser_raw.mly index daa2ce3163..917ab96e82 100644 --- a/src/ocaml/preprocess/parser_raw.mly +++ b/src/ocaml/preprocess/parser_raw.mly @@ -26,6 +26,9 @@ [@@@ocaml.warning "-9"] +[@@@ocaml.warning "-60"] module Str = Ast_helper.Str (* For ocamldep *) +[@@@ocaml.warning "+60"] + open Asttypes open Longident open Parsetree @@ -101,13 +104,13 @@ let push_loc x acc = let reloc_pat ~loc x = { x with ppat_loc = make_loc loc; - ppat_loc_stack = push_loc x.ppat_loc x.ppat_loc_stack };; + ppat_loc_stack = push_loc x.ppat_loc x.ppat_loc_stack } let reloc_exp ~loc x = { x with pexp_loc = make_loc loc; - pexp_loc_stack = push_loc x.pexp_loc x.pexp_loc_stack };; + pexp_loc_stack = push_loc x.pexp_loc x.pexp_loc_stack } let reloc_typ ~loc x = { x with ptyp_loc = make_loc loc; - ptyp_loc_stack = push_loc x.ptyp_loc x.ptyp_loc_stack };; + ptyp_loc_stack = push_loc x.ptyp_loc x.ptyp_loc_stack } let mkexpvar ~loc (name : string) = mkexp ~loc (Pexp_ident(mkrhs (Lident name) loc)) @@ -167,6 +170,10 @@ let mkuplus ~oploc name arg = | _ -> Pexp_apply(mkoperator ~loc:oploc ("~" ^ name), [Nolabel, arg]) +let mk_attr ~loc name payload = + Builtin_attributes.(register_attr Parser name); + Attr.mk ~loc name payload + (* TODO define an abstraction boundary between locations-as-pairs and locations-as-Location.t; it should be clear when we move from one world to the other *) @@ -209,11 +216,13 @@ let rec mktailpat nilloc = let open Location in function let mkstrexp e attrs = { pstr_desc = Pstr_eval (e, attrs); pstr_loc = e.pexp_loc } -let mkexp_constraint ~loc e (t1, t2) = - match t1, t2 with - | Some t, None -> mkexp ~loc (Pexp_constraint(e, t)) - | _, Some t -> mkexp ~loc (Pexp_coerce(e, t1, t)) - | None, None -> assert false +let mkexp_desc_constraint e t = + match t with + | Pconstraint t -> Pexp_constraint(e, t) + | Pcoerce(t1, t2) -> Pexp_coerce(e, t1, t2) + +let mkexp_constraint ~loc e t = + mkexp ~loc (mkexp_desc_constraint e t) let mkexp_opt_constraint ~loc e = function | None -> e @@ -227,6 +236,8 @@ let mkpat_opt_constraint ~loc p = function (*let syntax_error () = raise Syntaxerr.Escape_error*) +let removed_string_set loc = + raise_error Syntaxerr.(Error(Syntaxerr.Removed_string_set(make_loc loc))) (* Using the function [not_expecting] in a semantic action means that this syntactic form is recognized by the parser but is in fact incorrect. This @@ -312,7 +323,9 @@ let builtin_arraylike_name loc _ ~assign paren_kind n = let opname = if !Clflags.fast then "unsafe_" ^ opname else opname in let prefix = match paren_kind with | Paren -> Lident "Array" - | Bracket -> Lident "String" + | Bracket -> + if assign then removed_string_set loc; + Lident "String" | Brace -> let submodule_name = match n with | One -> "Array1" @@ -508,10 +521,11 @@ let extra_rhs_core_type ct ~pos = let docs = rhs_info pos in { ct with ptyp_attributes = add_info_attrs docs ct.ptyp_attributes } -(* +(* moved to ast_helper type let_binding = { lb_pattern: pattern; lb_expression: expression; + lb_constraint: value_constraint option; lb_is_pun: bool; lb_attributes: attributes; lb_docs: docs Lazy.t; @@ -524,10 +538,11 @@ type let_bindings = lbs_extension: string Asttypes.loc option } *) -let mklb first ~loc (p, e, is_pun) attrs = +let mklb first ~loc (p, e, typ, is_pun) attrs = { lb_pattern = p; lb_expression = e; + lb_constraint=typ; lb_is_pun = is_pun; lb_attributes = attrs; lb_docs = symbol_docs_lazy loc; @@ -560,7 +575,7 @@ let val_of_let_bindings ~loc lbs = Vb.mk ~loc:lb.lb_loc ~attrs:lb.lb_attributes ~docs:(Lazy.force lb.lb_docs) ~text:(Lazy.force lb.lb_text) - lb.lb_pattern lb.lb_expression) + ?value_constraint:lb.lb_constraint lb.lb_pattern lb.lb_expression) lbs.lbs_bindings in let str = mkstr ~loc (Pstr_value(lbs.lbs_rec, List.rev bindings)) in @@ -573,7 +588,7 @@ let expr_of_let_bindings ~loc lbs body = List.map (fun lb -> Vb.mk ~loc:lb.lb_loc ~attrs:lb.lb_attributes - lb.lb_pattern lb.lb_expression) + ?value_constraint:lb.lb_constraint lb.lb_pattern lb.lb_expression) lbs.lbs_bindings in mkexp_attrs ~loc (Pexp_let(lbs.lbs_rec, List.rev bindings, body)) @@ -584,13 +599,71 @@ let class_of_let_bindings ~loc lbs body = List.map (fun lb -> Vb.mk ~loc:lb.lb_loc ~attrs:lb.lb_attributes - lb.lb_pattern lb.lb_expression) + ?value_constraint:lb.lb_constraint lb.lb_pattern lb.lb_expression) lbs.lbs_bindings in (* Our use of let_bindings(no_ext) guarantees the following: *) assert (lbs.lbs_extension = None); mkclass ~loc (Pcl_let (lbs.lbs_rec, List.rev bindings, body)) +(* If all the parameters are [Pparam_newtype x], then return [Some xs] where + [xs] is the corresponding list of values [x]. This function is optimized for + the common case, where a list of parameters contains at least one value + parameter. +*) +let all_params_as_newtypes = + let is_newtype { pparam_desc; _ } = + match pparam_desc with + | Pparam_newtype _ -> true + | Pparam_val _ -> false + in + let as_newtype { pparam_desc; pparam_loc } = + match pparam_desc with + | Pparam_newtype x -> Some (x, pparam_loc) + | Pparam_val _ -> None + in + fun params -> + if List.for_all is_newtype params + then Some (List.filter_map as_newtype params) + else None + +(* Given a construct [fun (type a b c) : t -> e], we construct + [Pexp_newtype(a, Pexp_newtype(b, Pexp_newtype(c, Pexp_constraint(e, t))))] + rather than a [Pexp_function]. +*) +let mkghost_newtype_function_body newtypes body_constraint body = + let wrapped_body = + match body_constraint with + | None -> body + | Some body_constraint -> + let loc = { body.pexp_loc with loc_ghost = true } in + Exp.mk (mkexp_desc_constraint body body_constraint) ~loc + in + let expr = + List.fold_right + (fun (newtype, newtype_loc) e -> + (* Mints a ghost location that approximates the newtype's "extent" as + being from the start of the newtype param until the end of the + function body. + *) + let loc = (newtype_loc.Location.loc_start, body.pexp_loc.loc_end) in + ghexp (Pexp_newtype (newtype, e)) ~loc) + newtypes + wrapped_body + in + expr.pexp_desc + +let mkfunction params body_constraint body = + match body with + | Pfunction_cases _ -> Pexp_function (params, body_constraint, body) + | Pfunction_body body_exp -> + (* If all the params are newtypes, then we don't create a function node; + we create nested newtype nodes. *) + match all_params_as_newtypes params with + | None -> Pexp_function (params, body_constraint, body) + | Some newtypes -> + mkghost_newtype_function_body newtypes body_constraint body_exp + (* Alternatively, we could keep the generic module type in the Parsetree and extract the package type during type-checking. In that case, the assertions below should be turned into explicit checks. *) @@ -602,11 +675,11 @@ let package_type_of_module_type pmty = | Pwith_type (lid, ptyp) -> let loc = ptyp.ptype_loc in if ptyp.ptype_params <> [] then - err loc "parametrized types are not supported"; + err loc Syntaxerr.Parameterized_types; if ptyp.ptype_cstrs <> [] then - err loc "constrained types are not supported"; + err loc Syntaxerr.Constrained_types; if ptyp.ptype_private <> Public then - err loc "private types are not supported"; + err loc Syntaxerr.Private_types; (* restrictions below are checked by the 'with_constraint' rule *) (* assert (ptyp.ptype_kind = Ptype_abstract); *) @@ -616,7 +689,7 @@ let package_type_of_module_type pmty = | None -> None end | _ -> - err pmty.pmty_loc "only 'with type t =' constraints are supported"; + err pmty.pmty_loc Not_with_type; None in match pmty with @@ -624,8 +697,7 @@ let package_type_of_module_type pmty = | {pmty_desc = Pmty_with({pmty_desc = Pmty_ident lid}, cstrs)} -> (lid, List.filter_map map_cstr cstrs, pmty.pmty_attributes) | _ -> - err pmty.pmty_loc - "only module type identifier and 'with type' constraints are supported" + err pmty.pmty_loc Neither_identifier_nor_with_type ; (Location.mkloc (Lident "_") pmty.pmty_loc, [], []) let mk_directive_arg ~loc k = @@ -650,33 +722,6 @@ let merloc startpos ?endpos x = let attr = { attr_name = str; attr_loc = loc; attr_payload = PStr [] } in { x with pexp_attributes = attr :: x.pexp_attributes } -let val_of_lwt_bindings ~loc lbs = - let bindings = - List.map - (fun lb -> - Vb.mk ~loc:lb.lb_loc ~attrs:lb.lb_attributes - ~docs:(Lazy.force lb.lb_docs) - ~text:(Lazy.force lb.lb_text) - lb.lb_pattern (Fake.app Fake.Lwt.un_lwt lb.lb_expression)) - lbs.lbs_bindings - in - let str = mkstr ~loc (Pstr_value(lbs.lbs_rec, List.rev bindings)) in - match lbs.lbs_extension with - | None -> str - | Some id -> ghstr ~loc (Pstr_extension((id, PStr [str]), [])) - -let expr_of_lwt_bindings ~loc lbs body = - let bindings = - List.map - (fun lb -> - Vb.mk ~loc:lb.lb_loc ~attrs:lb.lb_attributes - lb.lb_pattern (Fake.app Fake.Lwt.un_lwt lb.lb_expression)) - lbs.lbs_bindings - in - Fake.app Fake.Lwt.in_lwt - (mkexp_attrs ~loc (Pexp_let(lbs.lbs_rec, List.rev bindings, body)) - (lbs.lbs_extension, [])) - %} %[@printer.header @@ -854,13 +899,6 @@ let expr_of_lwt_bindings ~loc lbs body = %token EOL "\\n" (* not great, but EOL is unused *) -%token LET_LWT [@cost 1] [@symbol "lwt"] -%token TRY_LWT [@cost 1] [@symbol "try_lwt"] -%token MATCH_LWT [@cost 1] [@symbol "match_lwt"] -%token FINALLY_LWT [@cost 1] [@symbol "finally"] -%token FOR_LWT [@cost 1] [@symbol "for_lwt"] -%token WHILE_LWT [@cost 1] [@symbol "while_lwt"] - %token DOTLESS [@cost 1] [@symbol ".<"] %token DOTTILDE [@cost 1] [@symbol ".~"] %token GREATERDOT [@cost 1] [@symbol ">."] @@ -891,10 +929,9 @@ The precedences must be listed from low to high. %nonassoc IN %nonassoc below_SEMI %nonassoc SEMI /* below EQUAL ({lbl=...; lbl=...}) */ -%nonassoc LET LET_LWT /* above SEMI ( ...; let ... in ...) */ +%nonassoc LET /* above SEMI ( ...; let ... in ...) */ %nonassoc below_WITH %nonassoc FUNCTION WITH /* below BAR (match ... with ...) */ -%nonassoc FINALLY_LWT %nonassoc AND /* above WITH (module rec A: SIG with ... and ...) */ %nonassoc THEN /* below ELSE (if ... then ...) */ %nonassoc ELSE /* (if ... then ... else ...) */ @@ -1091,6 +1128,27 @@ reversed_nonempty_llist(X): xs = rev(reversed_nonempty_llist(X)) { xs } +(* [reversed_nonempty_concat(X)] recognizes a nonempty sequence of [X]s (each of + which is a list), and produces an OCaml list of their concatenation in + reverse order -- that is, the last element of the last list in the input text + appears first in the list. +*) +reversed_nonempty_concat(X): + x = X + { List.rev x } +| xs = reversed_nonempty_concat(X) x = X + { List.rev_append x xs } + +(* [nonempty_concat(X)] recognizes a nonempty sequence of [X]s + (each of which is a list), and produces an OCaml list of their concatenation + in direct order -- that is, the first element of the first list in the input + text appears first in the list. +*) + +%inline nonempty_concat(X): + xs = rev(reversed_nonempty_concat(X)) + { xs } + (* [reversed_separated_nonempty_llist(separator, X)] recognizes a nonempty list of [X]s, separated with [separator]s, and produces an OCaml list in reverse order -- that is, the last element in the input text appears first in this @@ -1407,6 +1465,10 @@ module_expr [@recovery default_module_expr ()]: | STRUCT attributes structure error { unclosed "struct" $loc($1) "end" $loc($4) } *) + (* + | SIG error + { expecting $loc($1) "struct" } + *) | FUNCTOR attrs = attributes args = functor_args MINUSGREATER me = module_expr { wrap_mod_attrs ~loc:$sloc attrs ( List.fold_left (fun acc (startpos, arg) -> @@ -1424,10 +1486,9 @@ module_expr [@recovery default_module_expr ()]: | (* In a functor application, the actual argument must be parenthesized. *) me1 = module_expr me2 = paren_module_expr { Pmod_apply(me1, me2) } - | (* Application to unit is sugar for application to an empty structure. *) - me1 = module_expr LPAREN RPAREN - { (* TODO review mkmod location *) - Pmod_apply(me1, mkmod ~loc:$sloc (Pmod_structure [])) } + | (* Functor applied to unit. *) + me = module_expr LPAREN RPAREN + { Pmod_apply_unit me } | (* An extension. *) ex = extension { Pmod_extension ex } @@ -1576,6 +1637,10 @@ structure [@recovery []]: module_binding_body: EQUAL me = module_expr { me } + (* + | COLON error + { expecting $loc($1) "=" } + *) | mkmod( COLON mty = module_type EQUAL me = module_expr { Pmod_constraint(me, mty) } @@ -1712,6 +1777,10 @@ module_type [@recovery default_module_type ()]: | SIG attributes signature error { unclosed "sig" $loc($1) "end" $loc($4) } *) + (* + | STRUCT error + { expecting $loc($1) "sig" } + *) | FUNCTOR attrs = attributes args = functor_args MINUSGREATER mty = module_type %prec below_WITH @@ -1733,6 +1802,8 @@ module_type [@recovery default_module_type ()]: | mkmty( mkrhs(mty_longident) { Pmty_ident $1 } + | LPAREN RPAREN MINUSGREATER module_type + { Pmty_functor(Unit, $4) } | module_type MINUSGREATER module_type %prec below_WITH { Pmty_functor(Named (mknoloc None, $1), $3) } @@ -1826,6 +1897,10 @@ signature_item: module_declaration_body: COLON mty = module_type { mty } + (* + | EQUAL error + { expecting $loc($1) ":" } + *) | mkmty( arg_and_pos = functor_arg body = module_declaration_body { let (_, arg) = arg_and_pos in @@ -2309,17 +2384,48 @@ class_type_declarations: /* Core expressions */ -seq_expr: - | expr %prec below_SEMI { $1 } - | expr SEMI { $1 } - | mkexp(expr SEMI seq_expr +%inline or_function(EXPR): + | EXPR + { $1 } + | FUNCTION ext_attributes match_cases + { let loc = make_loc $sloc in + let cases = $3 in + (* There are two choices of where to put attributes: on the + Pexp_function node; on the Pfunction_cases body. We put them on the + Pexp_function node here because the compiler only uses + Pfunction_cases attributes for enabling/disabling warnings in + typechecking. For standalone function cases, we want the compiler to + respect, e.g., [@inline] attributes. + *) + let desc = mkfunction [] None (Pfunction_cases (cases, loc, [])) in + mkexp_attrs ~loc:$sloc desc $2 + } +; + +(* [fun_seq_expr] (and [fun_expr]) are legal expression bodies of a function. + [seq_expr] (and [expr]) are expressions that appear in other contexts + (e.g. subexpressions of the expression body of a function). + + [fun_seq_expr] can't be a bare [function _ -> ...]. [seq_expr] can. + + This distinction exists because [function _ -> ...] is parsed as a *function + cases* body of a function, not an expression body. This so functions can be + parsed with the intended arity. +*) +fun_seq_expr: + | fun_expr %prec below_SEMI { $1 } + | fun_expr SEMI { $1 } + | mkexp(fun_expr SEMI seq_expr { Pexp_sequence($1, $3) }) { $1 } - | expr SEMI PERCENT attr_id seq_expr + | fun_expr SEMI PERCENT attr_id seq_expr { let seq = mkexp ~loc:$sloc (Pexp_sequence ($1, $5)) in let payload = PStr [mkstrexp seq []] in mkexp ~loc:$sloc (Pexp_extension ($4, payload)) } ; +seq_expr: + | or_function(fun_seq_expr) { $1 } +; labeled_simple_pattern: QUESTION LPAREN label_let_pattern opt_default RPAREN { (Optional (fst $3), $4, snd $3) } @@ -2390,10 +2496,10 @@ let_pattern [@recovery default_pattern ()]: %inline qualified_dotop: ioption(DOT mod_longident {$2}) DOTOP { $1, $2 }; -%public expr [@recovery default_expr ()]: +%public fun_expr [@recovery default_expr ()]: simple_expr %prec below_HASH { $1 } - | expr_attrs + | fun_expr_attrs { let desc, attrs = $1 in mkexp_attrs ~loc:$sloc desc attrs } | mkexp(expr_) @@ -2406,7 +2512,7 @@ let_pattern [@recovery default_pattern ()]: let pbop_loc = make_loc $sloc in let let_ = {pbop_op; pbop_pat; pbop_exp; pbop_loc} in mkexp ~loc:$sloc (Pexp_letop{ let_; ands; body}) } - | expr COLONCOLON expr + | fun_expr COLONCOLON expr { mkexp_cons ~loc:$sloc $loc($2) (ghexp ~loc:$sloc (Pexp_tuple[$1;(merloc $endpos($2) $3)])) } | mkrhs(label) LESSMINUS expr { mkexp ~loc:$sloc (Pexp_setinstvar($1, $3)) } @@ -2416,7 +2522,7 @@ let_pattern [@recovery default_pattern ()]: { mk_indexop_expr builtin_indexing_operators ~loc:$sloc $1 } | indexop_expr(qualified_dotop, expr_semi_list, LESSMINUS v=expr {Some v}) { mk_indexop_expr user_indexing_operators ~loc:$sloc $1 } - | expr attribute + | fun_expr attribute { Exp.attr $1 $2 } (* /* BEGIN AVOID */ @@ -2425,7 +2531,10 @@ let_pattern [@recovery default_pattern ()]: /* END AVOID */ *) ; -%inline expr_attrs: +%public %inline expr: + | or_function(fun_expr) { $1 } +; +%inline fun_expr_attrs: | LET MODULE ext_attributes mkrhs(module_name) module_binding_body IN seq_expr { Pexp_letmodule($4, $5, (merloc $endpos($6) $7)), $3 } | LET EXCEPTION ext_attributes let_exception_declaration IN seq_expr @@ -2434,13 +2543,12 @@ let_pattern [@recovery default_pattern ()]: { let open_loc = make_loc ($startpos($2), $endpos($5)) in let od = Opn.mk $5 ~override:$3 ~loc:open_loc in Pexp_open(od, (merloc $endpos($6) $7)), $4 } - | FUNCTION ext_attributes match_cases - { Pexp_function $3, $2 } - | FUN ext_attributes labeled_simple_pattern fun_def - { let (l,o,p) = $3 in - Pexp_fun(l, o, p, $4), $2 } - | FUN ext_attributes LPAREN TYPE lident_list RPAREN fun_def - { (mk_newtypes ~loc:$sloc $5 $7).pexp_desc, $2 } + /* Cf #5939: we used to accept (fun p when e0 -> e) */ + | FUN ext_attributes fun_params preceded(COLON, atomic_type)? + MINUSGREATER fun_body + { let body_constraint = Option.map (fun x -> Pconstraint x) $4 in + mkfunction $3 body_constraint $6, $2 + } | MATCH ext_attributes seq_expr WITH match_cases { Pexp_match($3, $5), $2 } | TRY ext_attributes seq_expr WITH match_cases @@ -2455,6 +2563,10 @@ let_pattern [@recovery default_pattern ()]: { Pexp_ifthenelse($3, (merloc $endpos($4) $5), None), $2 } | WHILE ext_attributes seq_expr DO seq_expr DONE { Pexp_while($3, (merloc $endpos($4) $5)), $2 } + (* + | WHILE ext_attributes seq_expr DO seq_expr error + { unclosed "do" $loc($1) "done" $loc($2) } + *) | FOR ext_attributes pattern EQUAL seq_expr direction_flag seq_expr DO seq_expr DONE { Pexp_for($3, (merloc $endpos($4) $5), (merloc $endpos($6) $7), $6, (merloc $endpos($8) $9)), $2 } @@ -2472,7 +2584,7 @@ let_pattern [@recovery default_pattern ()]: { Pexp_construct($1, Some $2) } | name_tag simple_expr %prec below_HASH { Pexp_variant($1, Some $2) } - | e1 = expr op = op(infix_operator) e2 = expr + | e1 = fun_expr op = op(infix_operator) e2 = expr { mkinfix e1 op e2 } | subtractive expr %prec prec_unary_minus { mkuminus ~oploc:$loc($1) $1 $2 } @@ -2666,42 +2778,38 @@ labeled_simple_expr: ; let_binding_body_no_punning: let_ident strict_binding - { ($1, $2) } + { ($1, $2, None) } | let_ident type_constraint EQUAL seq_expr { let v = $1 in (* PR#7344 *) let t = match $2 with - Some t, None -> t - | _, Some t -> t - | _ -> assert false + Pconstraint t -> + Pvc_constraint { locally_abstract_univars = []; typ=t } + | Pcoerce (ground, coercion) -> Pvc_coercion { ground; coercion} in - let loc = Location.(t.ptyp_loc.loc_start, t.ptyp_loc.loc_end) in - let typ = ghtyp ~loc (Ptyp_poly([],t)) in - let patloc = ($startpos($1), $endpos($2)) in - (ghpat ~loc:patloc (Ppat_constraint(v, typ)), - mkexp_constraint ~loc:$sloc $4 $2) } + (v, $4, Some t) + } | let_ident COLON poly(core_type) EQUAL seq_expr - { let patloc = ($startpos($1), $endpos($3)) in - (ghpat ~loc:patloc - (Ppat_constraint($1, ghtyp ~loc:($loc($3)) $3)), - $5) } + { + let t = ghtyp ~loc:($loc($3)) $3 in + ($1, $5, Some (Pvc_constraint { locally_abstract_univars = []; typ=t })) + } | let_ident COLON TYPE lident_list DOT core_type EQUAL seq_expr - { let exp, poly = - wrap_type_annotation ~loc:$sloc $4 $6 $8 in - let loc = ($startpos($1), $endpos($6)) in - (ghpat ~loc (Ppat_constraint($1, poly)), exp) } + { let constraint' = + Pvc_constraint { locally_abstract_univars=$4; typ = $6} + in + ($1, $8, Some constraint') } | pattern_no_exn EQUAL seq_expr - { ($1, $3) } + { ($1, $3, None) } | simple_pattern_not_ident COLON core_type EQUAL seq_expr - { let loc = ($startpos($1), $endpos($3)) in - (ghpat ~loc (Ppat_constraint($1, $3)), $5) } + { ($1, $5, Some(Pvc_constraint { locally_abstract_univars=[]; typ=$3 })) } ; let_binding_body: | let_binding_body_no_punning - { let p,e = $1 in (p,e,false) } + { let p,e,c = $1 in (p,e,c,false) } /* BEGIN AVOID */ | val_ident %prec below_HASH - { (mkpatvar ~loc:$loc $1, mkexpvar ~loc:$loc $1, true) } + { (mkpatvar ~loc:$loc $1, mkexpvar ~loc:$loc $1, None, true) } (* The production that allows puns is marked so that [make list-parse-errors] does not attempt to exploit it. That would be problematic because it would then generate bindings such as [let x], which are rejected by the @@ -2759,19 +2867,26 @@ letop_bindings: let and_ = {pbop_op; pbop_pat; pbop_exp; pbop_loc} in let_pat, let_exp, and_ :: rev_ands } ; -fun_binding: - strict_binding - { $1 } - | type_constraint EQUAL seq_expr - { mkexp_constraint ~loc:$sloc $3 $1 } -; strict_binding: EQUAL seq_expr { $2 } - | labeled_simple_pattern fun_binding - { let (l, o, p) = $1 in ghexp ~loc:$sloc (Pexp_fun(l, o, p, $2)) } - | LPAREN TYPE lident_list RPAREN fun_binding - { mk_newtypes ~loc:$sloc $3 $5 } + | fun_params type_constraint? EQUAL fun_body + { ghexp ~loc:$sloc (mkfunction $1 $2 $4) + } +; +fun_body: + | FUNCTION ext_attributes match_cases + { let ext, attrs = $2 in + match ext with + | None -> Pfunction_cases ($3, make_loc $sloc, attrs) + | Some _ -> + (* function%foo extension nodes interrupt the arity *) + let cases = Pfunction_cases ($3, make_loc $sloc, []) in + Pfunction_body + (mkexp_attrs ~loc:$sloc (mkfunction [] None cases) $2) + } + | fun_seq_expr + { Pfunction_body $1 } ; %inline match_cases: xs = preceded_or_separated_nonempty_llist(BAR, match_case) @@ -2786,6 +2901,7 @@ match_case: { Exp.case $1 (merloc $endpos($2) (Exp.unreachable ~loc:(make_loc $loc($3)) ())) } ; +(* fun_def: MINUSGREATER seq_expr { (merloc $endpos($1) $2) } @@ -2801,6 +2917,30 @@ fun_def: | LPAREN TYPE lident_list RPAREN fun_def { mk_newtypes ~loc:$sloc $3 $5 } ; +*) +fun_param_as_list: + | LPAREN TYPE ty_params = lident_list RPAREN + { (* We desugar (type a b c) to (type a) (type b) (type c). + If we do this desugaring, the loc for each parameter is a ghost. + *) + let loc = + match ty_params with + | [] -> assert false (* lident_list is non-empty *) + | [_] -> make_loc $sloc + | _ :: _ :: _ -> ghost_loc $sloc + in + List.map + (fun x -> { pparam_loc = loc; pparam_desc = Pparam_newtype x }) + ty_params + } + | labeled_simple_pattern + { let a, b, c = $1 in + [ { pparam_loc = make_loc $sloc; pparam_desc = Pparam_val (a, b, c) } ] + } +; +fun_params: + | nonempty_concat(fun_param_as_list) { $1 } +; %inline expr_comma_list: es = separated_nontrivial_llist(COMMA, expr) { es } @@ -2846,9 +2986,9 @@ record_expr_content: { es } ; type_constraint: - COLON core_type { (Some $2, None) } - | COLON core_type COLONGREATER core_type { (Some $2, Some $4) } - | COLONGREATER core_type { (None, Some $2) } + COLON core_type { Pconstraint $2 } + | COLON core_type COLONGREATER core_type { Pcoerce (Some $2, $4) } + | COLONGREATER core_type { Pcoerce (None, $2) } (*| COLON error { syntax_error() } *) (*| COLONGREATER error { syntax_error() } *) ; @@ -3434,8 +3574,8 @@ with_type_binder: /* Polymorphic types */ %inline typevar: - QUOTE mkrhs(ident) - { $2 } + QUOTE ident + { mkrhs $2 $sloc } ; %inline typevar_list: nonempty_llist(typevar) @@ -3489,7 +3629,7 @@ alias_type: function_type { $1 } | mktyp( - ty = alias_type AS QUOTE tyvar = ident + ty = alias_type AS tyvar = typevar { Ptyp_alias(ty, tyvar) } ) { $1 } @@ -3546,44 +3686,100 @@ tuple_type: - applications of type constructors: int, int list, int option list - variant types: [`A] *) + + +(* + Delimited types: + - parenthesised type (type) + - first-class module types (module S) + - object types < x: t; ... > + - variant types [ `A ] + - extension [%foo ...] + + We support local opens on the following classes of types: + - parenthesised + - first-class module types + - variant types + + Object types are not support for local opens due to a potential + conflict with MetaOCaml syntax: + M.< x: t, y: t > + and quoted expressions: + .< e >. + + Extension types are not support for local opens merely as a precaution. +*) +delimited_type_supporting_local_open: + | LPAREN type_ = core_type RPAREN + { type_ } + | LPAREN MODULE attrs = ext_attributes package_type = package_type RPAREN + { wrap_typ_attrs ~loc:$sloc (reloc_typ ~loc:$sloc package_type) attrs } + | mktyp( + LBRACKET field = tag_field RBRACKET + { Ptyp_variant([ field ], Closed, None) } + | LBRACKET BAR fields = row_field_list RBRACKET + { Ptyp_variant(fields, Closed, None) } + | LBRACKET field = row_field BAR fields = row_field_list RBRACKET + { Ptyp_variant(field :: fields, Closed, None) } + | LBRACKETGREATER BAR? fields = row_field_list RBRACKET + { Ptyp_variant(fields, Open, None) } + | LBRACKETGREATER RBRACKET + { Ptyp_variant([], Open, None) } + | LBRACKETLESS BAR? fields = row_field_list RBRACKET + { Ptyp_variant(fields, Closed, Some []) } + | LBRACKETLESS BAR? fields = row_field_list + GREATER + tags = name_tag_list + RBRACKET + { Ptyp_variant(fields, Closed, Some tags) } + ) + { $1 } +; + +object_type: + | mktyp( + LESS meth_list = meth_list GREATER + { let (f, c) = meth_list in Ptyp_object (f, c) } + | LESS GREATER + { Ptyp_object ([], Closed) } + ) + { $1 } +; + +extension_type: + | mktyp ( + ext = extension + { Ptyp_extension ext } + ) + { $1 } +; + +delimited_type: + | object_type + | extension_type + | delimited_type_supporting_local_open + { $1 } +; + atomic_type: - | LPAREN core_type RPAREN - { $2 } - | LPAREN MODULE ext_attributes package_type RPAREN - { wrap_typ_attrs ~loc:$sloc (reloc_typ ~loc:$sloc $4) $3 } + | type_ = delimited_type + { type_ } | mktyp( /* begin mktyp group */ - QUOTE ident - { Ptyp_var $2 } - | UNDERSCORE - { Ptyp_any } - | tys = actual_type_parameters + tys = actual_type_parameters tid = mkrhs(type_longident) - { Ptyp_constr(tid, tys) } - | LESS meth_list GREATER - { let (f, c) = $2 in Ptyp_object (f, c) } - | LESS GREATER - { Ptyp_object ([], Closed) } + { Ptyp_constr (tid, tys) } | tys = actual_type_parameters HASH cid = mkrhs(clty_longident) - { Ptyp_class(cid, tys) } - | LBRACKET tag_field RBRACKET - (* not row_field; see CONFLICTS *) - { Ptyp_variant([$2], Closed, None) } - | LBRACKET BAR row_field_list RBRACKET - { Ptyp_variant($3, Closed, None) } - | LBRACKET row_field BAR row_field_list RBRACKET - { Ptyp_variant($2 :: $4, Closed, None) } - | LBRACKETGREATER BAR? row_field_list RBRACKET - { Ptyp_variant($3, Open, None) } - | LBRACKETGREATER RBRACKET - { Ptyp_variant([], Open, None) } - | LBRACKETLESS BAR? row_field_list RBRACKET - { Ptyp_variant($3, Closed, Some []) } - | LBRACKETLESS BAR? row_field_list GREATER name_tag_list RBRACKET - { Ptyp_variant($3, Closed, Some $5) } - | extension - { Ptyp_extension $1 } + { Ptyp_class (cid, tys) } + | mod_ident = mkrhs(mod_ext_longident) + DOT + type_ = delimited_type_supporting_local_open + { Ptyp_open (mod_ident, type_) } + | QUOTE ident = ident + { Ptyp_var ident } + | UNDERSCORE + { Ptyp_any } ) { $1 } /* end mktyp group */ ; @@ -3602,7 +3798,7 @@ atomic_type: | /* empty */ { [] } | ty = atomic_type - { [ty] } + { [ ty ] } | LPAREN tys = separated_nontrivial_llist(COMMA, core_type) RPAREN { tys } ; @@ -4010,17 +4206,17 @@ attr_id: ) { $1 } ; attribute: - LBRACKETAT attr_id payload RBRACKET - { Attr.mk ~loc:(make_loc $sloc) $2 $3 } + LBRACKETAT attr_id attr_payload RBRACKET + { mk_attr ~loc:(make_loc $sloc) $2 $3 } ; post_item_attribute: - LBRACKETATAT attr_id payload RBRACKET - { Attr.mk ~loc:(make_loc $sloc) $2 $3 } + LBRACKETATAT attr_id attr_payload RBRACKET + { mk_attr ~loc:(make_loc $sloc) $2 $3 } ; floating_attribute: - LBRACKETATATAT attr_id payload RBRACKET + LBRACKETATATAT attr_id attr_payload RBRACKET { mark_symbol_docs $sloc; - Attr.mk ~loc:(make_loc $sloc) $2 $3 } + mk_attr ~loc:(make_loc $sloc) $2 $3 } ; %inline post_item_attributes: post_item_attribute* @@ -4031,7 +4227,7 @@ floating_attribute: { $1 } ; ext: - | /* empty */ { None } + | /* empty */ { None } | PERCENT attr_id { Some $2 } ; %inline no_ext: @@ -4060,6 +4256,12 @@ payload: | QUESTION pattern { PPat ($2, None) } | QUESTION pattern WHEN seq_expr { PPat ($2, Some $4) } ; +attr_payload: + payload + { Builtin_attributes.mark_payload_attrs_used $1; + $1 + } +; %public simple_expr: | DOTLESS expr GREATERDOT @@ -4068,51 +4270,4 @@ payload: { Fake.Meta.uncode $startpos $endpos $2 } ; -(* Lwt *) -%public structure_item: -| lwt_bindings - { val_of_lwt_bindings ~loc:$loc $1 } - -lwt_binding: - LET_LWT ext_attributes rec_flag let_binding_body post_item_attributes - { let (ext, attr) = $2 in - mklbs ext $3 (mklb ~loc:$loc($4) true $4 (attr@$5)) } -; -lwt_bindings: - lwt_binding { $1 } - | lwt_bindings and_let_binding { addlb $1 $2 } -; - -%public expr: -| lwt_bindings IN seq_expr - { expr_of_lwt_bindings ~loc:$loc $1 (merloc $endpos($2) $3) } -| MATCH_LWT ext_attributes seq_expr WITH match_cases - { let expr = mkexp_attrs ~loc:$loc - (Pexp_match(Fake.app Fake.Lwt.un_lwt $3, List.rev $5)) $2 in - Fake.app Fake.Lwt.in_lwt expr } -| TRY_LWT ext_attributes seq_expr %prec below_WITH - { reloc_exp ~loc:$loc (Fake.app Fake.Lwt.in_lwt $3) } -| TRY_LWT ext_attributes seq_expr WITH match_cases - { mkexp_attrs ~loc:$loc - (Pexp_try(Fake.app Fake.Lwt.in_lwt $3, List.rev $5)) $2 } -| TRY_LWT ext_attributes seq_expr FINALLY_LWT seq_expr - { Fake.app (Fake.app Fake.Lwt.finally_ $3) $5 } -| TRY_LWT ext_attributes seq_expr WITH match_cases FINALLY_LWT seq_expr - { let expr = mkexp_attrs ~loc:$loc - (Pexp_try (Fake.app Fake.Lwt.in_lwt $3, List.rev $5)) $2 in - Fake.app (Fake.app Fake.Lwt.finally_ expr) $7 } -| WHILE_LWT ext_attributes seq_expr DO seq_expr DONE - { let expr = Pexp_while ($3, Fake.(app Lwt.un_lwt $5)) in - Fake.(app Lwt.to_lwt (mkexp_attrs ~loc:$loc expr $2)) } -| FOR_LWT ext_attributes pattern EQUAL seq_expr direction_flag seq_expr DO seq_expr DONE - { let expr = Pexp_for ($3, $5, $7, $6, Fake.(app Lwt.un_lwt $9)) in - Fake.(app Lwt.to_lwt (mkexp_attrs ~loc:$loc expr $2)) } -| FOR_LWT ext_attributes pattern IN seq_expr DO seq_expr DONE - { mkexp_attrs ~loc:$loc - (Pexp_let (Nonrecursive, [Vb.mk $3 (Fake.(app Lwt.un_stream $5))], - Fake.(app Lwt.unit_lwt $7))) - $2 - } -; - %% diff --git a/src/ocaml/preprocess/parser_recover.ml b/src/ocaml/preprocess/parser_recover.ml index ed931709b7..cc51826cc9 100644 --- a/src/ocaml/preprocess/parser_recover.ml +++ b/src/ocaml/preprocess/parser_recover.ml @@ -19,7 +19,6 @@ module Default = struct let value (type a) : a MenhirInterpreter.symbol -> a = function | MenhirInterpreter.T MenhirInterpreter.T_error -> () | MenhirInterpreter.T MenhirInterpreter.T_WITH -> () - | MenhirInterpreter.T MenhirInterpreter.T_WHILE_LWT -> () | MenhirInterpreter.T MenhirInterpreter.T_WHILE -> () | MenhirInterpreter.T MenhirInterpreter.T_WHEN -> () | MenhirInterpreter.T MenhirInterpreter.T_VIRTUAL -> () @@ -27,7 +26,6 @@ module Default = struct | MenhirInterpreter.T MenhirInterpreter.T_UNDERSCORE -> () | MenhirInterpreter.T MenhirInterpreter.T_UIDENT -> "_" | MenhirInterpreter.T MenhirInterpreter.T_TYPE -> () - | MenhirInterpreter.T MenhirInterpreter.T_TRY_LWT -> () | MenhirInterpreter.T MenhirInterpreter.T_TRY -> () | MenhirInterpreter.T MenhirInterpreter.T_TRUE -> () | MenhirInterpreter.T MenhirInterpreter.T_TO -> () @@ -66,11 +64,9 @@ module Default = struct | MenhirInterpreter.T MenhirInterpreter.T_MINUSDOT -> () | MenhirInterpreter.T MenhirInterpreter.T_MINUS -> () | MenhirInterpreter.T MenhirInterpreter.T_METHOD -> () - | MenhirInterpreter.T MenhirInterpreter.T_MATCH_LWT -> () | MenhirInterpreter.T MenhirInterpreter.T_MATCH -> () | MenhirInterpreter.T MenhirInterpreter.T_LPAREN -> () | MenhirInterpreter.T MenhirInterpreter.T_LIDENT -> "_" - | MenhirInterpreter.T MenhirInterpreter.T_LET_LWT -> () | MenhirInterpreter.T MenhirInterpreter.T_LETOP -> raise Not_found | MenhirInterpreter.T MenhirInterpreter.T_LET -> () | MenhirInterpreter.T MenhirInterpreter.T_LESSMINUS -> () @@ -108,10 +104,8 @@ module Default = struct | MenhirInterpreter.T MenhirInterpreter.T_FUNCTOR -> () | MenhirInterpreter.T MenhirInterpreter.T_FUNCTION -> () | MenhirInterpreter.T MenhirInterpreter.T_FUN -> () - | MenhirInterpreter.T MenhirInterpreter.T_FOR_LWT -> () | MenhirInterpreter.T MenhirInterpreter.T_FOR -> () | MenhirInterpreter.T MenhirInterpreter.T_FLOAT -> ("0.",None) - | MenhirInterpreter.T MenhirInterpreter.T_FINALLY_LWT -> () | MenhirInterpreter.T MenhirInterpreter.T_FALSE -> () | MenhirInterpreter.T MenhirInterpreter.T_EXTERNAL -> () | MenhirInterpreter.T MenhirInterpreter.T_EXCEPTION -> () @@ -206,6 +200,7 @@ module Default = struct | MenhirInterpreter.N MenhirInterpreter.N_reversed_nonempty_llist_name_tag_ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_reversed_nonempty_llist_labeled_simple_expr_ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_reversed_nonempty_llist_functor_arg_ -> raise Not_found + | MenhirInterpreter.N MenhirInterpreter.N_reversed_nonempty_concat_fun_param_as_list_ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_reversed_llist_preceded_CONSTRAINT_constrain__ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_reversed_bar_llist_extension_constructor_declaration_ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_reversed_bar_llist_extension_constructor_ -> raise Not_found @@ -244,6 +239,7 @@ module Default = struct | MenhirInterpreter.N MenhirInterpreter.N_option_preceded_EQUAL_module_type__ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_option_preceded_EQUAL_expr__ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_option_preceded_COLON_core_type__ -> raise Not_found + | MenhirInterpreter.N MenhirInterpreter.N_option_preceded_COLON_atomic_type__ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_option_preceded_AS_mkrhs_LIDENT___ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_option_SEMI_ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_option_BAR_ -> raise Not_found @@ -251,6 +247,7 @@ module Default = struct | MenhirInterpreter.N MenhirInterpreter.N_operator -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_open_description -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_open_declaration -> raise Not_found + | MenhirInterpreter.N MenhirInterpreter.N_object_type -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_nonempty_type_kind -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_nonempty_list_raw_string_ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_nonempty_list_mkrhs_LIDENT__ -> raise Not_found @@ -272,14 +269,12 @@ module Default = struct | MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_longident_UIDENT_ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_longident_LIDENT_ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_ext_longident_ident_ -> raise Not_found - | MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_ext_longident___anonymous_41_ -> raise Not_found + | MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_ext_longident___anonymous_43_ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_ext_longident_UIDENT_ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_mk_longident_mod_ext_longident_LIDENT_ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_method_ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_meth_list -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_match_case -> raise Not_found - | MenhirInterpreter.N MenhirInterpreter.N_lwt_bindings -> raise Not_found - | MenhirInterpreter.N MenhirInterpreter.N_lwt_binding -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_listx_SEMI_record_pat_field_UNDERSCORE_ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_list_use_file_element_ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_list_text_str_structure_item__ -> raise Not_found @@ -323,16 +318,21 @@ module Default = struct | MenhirInterpreter.N MenhirInterpreter.N_functor_args -> [] | MenhirInterpreter.N MenhirInterpreter.N_functor_arg -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_function_type -> raise Not_found - | MenhirInterpreter.N MenhirInterpreter.N_fun_def -> raise Not_found - | MenhirInterpreter.N MenhirInterpreter.N_fun_binding -> raise Not_found + | MenhirInterpreter.N MenhirInterpreter.N_fun_seq_expr -> raise Not_found + | MenhirInterpreter.N MenhirInterpreter.N_fun_params -> raise Not_found + | MenhirInterpreter.N MenhirInterpreter.N_fun_param_as_list -> raise Not_found + | MenhirInterpreter.N MenhirInterpreter.N_fun_expr -> default_expr () + | MenhirInterpreter.N MenhirInterpreter.N_fun_body -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_formal_class_parameters -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_floating_attribute -> raise Not_found + | MenhirInterpreter.N MenhirInterpreter.N_extension_type -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_extension_constructor_rebind_epsilon_ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_extension_constructor_rebind_BAR_ -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_extension -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_ext -> raise Not_found - | MenhirInterpreter.N MenhirInterpreter.N_expr -> default_expr () | MenhirInterpreter.N MenhirInterpreter.N_direction_flag -> raise Not_found + | MenhirInterpreter.N MenhirInterpreter.N_delimited_type_supporting_local_open -> raise Not_found + | MenhirInterpreter.N MenhirInterpreter.N_delimited_type -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_core_type -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_constructor_declarations -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_constructor_arguments -> raise Not_found @@ -355,6 +355,7 @@ module Default = struct | MenhirInterpreter.N MenhirInterpreter.N_class_field -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_class_expr -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_attribute -> raise Not_found + | MenhirInterpreter.N MenhirInterpreter.N_attr_payload -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_attr_id -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_atomic_type -> raise Not_found | MenhirInterpreter.N MenhirInterpreter.N_any_longident -> raise Not_found @@ -379,18 +380,16 @@ type decision = | Select of (int -> action list) let depth = - [|0;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;2;3;2;2;1;2;1;2;3;1;1;1;2;3;1;2;3;1;1;1;1;1;2;3;1;1;1;2;2;1;2;2;1;1;2;1;1;1;1;1;1;2;3;4;1;1;5;6;6;1;1;2;1;2;3;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;2;1;2;3;4;5;2;3;4;5;2;3;4;5;1;1;1;1;1;1;2;3;1;4;5;1;1;1;1;1;2;1;2;3;1;1;1;2;2;3;4;1;2;3;4;1;1;2;1;2;3;1;1;2;4;1;2;1;1;1;2;2;1;1;1;2;2;1;2;3;2;3;5;6;1;1;1;1;1;2;1;1;1;2;1;2;1;1;1;1;1;2;3;4;1;2;3;1;2;3;1;1;2;3;3;1;1;4;1;2;1;1;1;2;3;1;2;3;1;1;1;1;2;1;2;3;1;4;1;1;2;1;1;2;3;1;1;1;1;2;1;2;2;1;1;1;2;3;4;2;3;1;2;3;1;2;2;1;2;1;1;2;1;2;1;1;3;2;3;2;1;2;3;4;1;2;3;3;1;1;3;4;2;3;1;2;1;3;4;2;1;3;2;3;4;5;1;2;1;2;1;2;3;2;3;4;5;3;4;3;4;4;5;6;2;1;2;2;1;1;2;3;1;1;2;1;1;1;1;1;1;4;1;1;2;3;1;1;1;2;3;4;1;2;3;1;1;1;2;3;2;3;2;1;2;1;1;2;3;1;2;4;5;6;1;1;1;2;3;2;3;2;3;3;4;5;2;3;2;3;2;4;4;5;4;5;3;4;2;3;1;2;3;3;2;3;4;5;1;6;5;2;2;3;1;1;2;1;2;3;3;4;2;1;2;3;1;1;1;1;1;2;1;2;3;3;4;5;1;2;1;2;3;4;1;2;1;1;2;3;4;5;1;2;1;2;2;3;1;1;2;1;2;3;4;1;5;2;1;2;3;1;2;4;5;4;5;6;2;3;4;5;1;1;2;3;4;5;2;1;2;3;3;1;1;1;4;5;2;3;2;3;4;2;3;4;1;3;2;3;1;2;3;4;5;3;4;1;5;2;3;2;3;3;4;5;2;2;1;1;6;7;1;1;1;1;1;1;1;1;1;2;3;1;2;3;1;2;3;1;2;3;1;1;2;1;2;3;4;5;6;7;1;1;2;3;4;5;1;2;3;4;5;1;1;1;2;1;1;2;3;4;1;1;4;5;6;7;8;9;10;1;1;1;1;2;3;4;1;2;3;4;2;3;2;3;1;1;1;2;3;1;2;1;2;3;4;4;5;2;1;2;1;2;2;3;2;3;4;5;1;2;1;2;1;1;1;1;1;2;3;1;1;2;3;1;2;3;2;3;2;1;2;1;2;2;3;4;5;3;2;3;2;3;2;3;2;3;2;3;2;3;2;3;2;3;2;3;2;3;2;3;2;3;2;3;2;3;2;3;2;3;2;3;2;3;2;3;2;3;1;2;1;2;3;4;5;1;2;3;2;3;2;3;2;3;2;3;2;1;1;2;3;1;3;1;2;1;2;3;4;1;2;3;4;5;1;2;6;1;2;7;2;3;4;5;1;2;1;2;3;4;6;7;1;2;3;4;5;6;1;2;8;4;5;6;1;2;1;2;1;2;3;4;5;1;2;3;4;5;1;2;3;2;3;6;7;1;2;8;9;1;1;2;3;1;1;2;3;1;4;1;1;1;1;2;3;1;2;3;4;5;6;7;1;2;3;1;2;1;1;2;3;2;1;5;1;1;2;3;6;7;8;1;2;3;4;5;6;4;2;3;4;2;5;6;7;1;1;1;2;3;4;5;6;7;1;1;2;3;1;1;2;3;4;1;1;2;8;9;10;1;1;1;2;3;4;5;6;4;4;1;2;3;3;4;5;3;3;1;7;8;9;6;7;1;8;9;10;2;1;1;4;5;6;7;8;9;6;7;8;5;6;7;8;9;1;1;2;3;4;5;6;2;3;4;5;1;2;3;4;5;6;7;8;2;3;4;5;6;7;4;5;6;7;8;1;2;3;4;5;6;7;9;4;5;6;7;1;2;5;6;1;2;1;2;3;4;5;1;2;3;4;1;2;3;4;1;5;1;2;3;6;7;8;1;2;1;2;3;3;1;2;1;2;1;2;3;4;5;6;7;1;2;1;2;1;2;3;4;5;6;7;1;2;1;2;3;4;5;6;1;2;3;4;2;3;1;1;1;7;2;3;4;5;6;3;4;1;2;1;2;3;3;4;4;5;1;2;1;1;2;9;10;1;2;3;4;5;6;7;8;9;11;2;3;4;5;6;7;1;2;3;4;1;1;1;2;1;2;3;1;1;4;1;3;5;8;9;1;2;3;4;5;6;7;8;9;10;1;1;1;1;1;1;1;1;2;1;2;1;1;2;3;4;5;6;7;8;2;1;1;2;3;4;5;6;7;8;9;2;1;1;2;2;1;2;1;2;3;4;5;6;1;1;2;3;1;1;2;3;4;5;6;5;6;7;2;3;1;1;2;1;2;2;3;4;5;2;3;4;5;4;5;6;1;1;2;3;4;5;6;7;8;9;10;11;6;7;8;5;1;1;1;2;3;1;2;2;3;1;1;2;1;2;2;3;4;5;2;3;4;5;6;7;8;9;10;5;6;7;4;1;2;3;4;1;2;3;1;1;2;3;4;5;6;7;2;3;4;5;6;1;2;3;4;1;2;1;2;1;2;1;1;1;2;1;2;2;1;1;3;2;2;3;2;3;7;3;4;5;6;2;3;4;5;2;3;3;4;5;4;1;2;5;6;2;3;4;5;1;2;3;4;4;5;1;2;1;1;2;2;1;2;3;4;1;2;7;8;1;2;3;4;5;6;7;8;9;1;1;1;2;3;4;5;6;1;1;1;1;1;1;2;2;1;2;1;2;1;2;1;1;1;1;2;3;3;4;1;1;1;3;4;3;4;4;3;3;4;5;3;4;5;3;4;5;6;7;1;2;3;5;6;7;5;6;7;3;2;3;4;5;6;7;3;4;5;6;7;3;4;5;6;7;2;3;4;5;6;7;3;4;5;6;7;3;4;5;6;7;3;4;5;6;7;8;9;5;6;7;8;9;5;6;7;8;9;3;4;5;2;2;4;5;3;4;5;3;4;5;5;1;2;3;2;3;4;2;3;1;1;4;5;3;4;4;5;3;4;4;5;3;4;5;3;1;2;3;1;1;2;3;4;5;1;4;5;1;2;3;3;6;1;1;7;8;9;10;11;6;7;8;9;5;6;7;8;9;10;11;2;1;2;3;4;1;2;3;4;1;2;5;8;4;5;3;4;5;2;3;3;2;4;2;3;1;4;5;6;7;8;4;4;5;4;2;3;2;2;3;2;2;3;4;2;2;3;2;3;8;3;4;5;6;7;2;3;4;5;6;7;8;2;3;4;5;6;7;8;9;2;5;2;2;4;5;2;2;3;4;5;6;7;8;3;4;5;6;7;2;3;4;2;5;6;3;2;2;3;2;2;3;4;5;6;6;7;8;2;3;3;4;4;5;6;4;5;6;4;5;5;6;7;5;6;7;7;8;9;5;6;2;3;4;5;2;3;4;2;3;4;3;4;5;6;1;7;1;2;3;2;2;3;3;4;5;2;3;4;5;4;2;3;2;3;2;3;2;3;4;2;2;2;2;6;7;8;1;2;3;4;5;9;10;2;2;1;1;1;1;1;2;3;4;4;5;5;6;7;8;9;3;4;5;5;6;6;7;3;4;7;8;2;3;3;4;5;4;5;6;4;5;6;4;5;6;7;8;5;6;4;5;6;7;3;4;3;4;5;6;7;1;2;1;0;1;2;1;0;1;2;3;1;1;1;2;3;4;5;3;3;1;1;1;1;2;0;1;1;2;0;1;1;2;0;1;2;1;0;1;1;2;0;1;1;2;0;1;1;2;0;1;1;2;0;1;1;2;0;1;2;1;0;1;2;1;1;2;0;1;2;3;3;3;3;3;3;1;1;1;2;1;2;1;2;3;1;2;0;1;1;1;2;2;2;3;4;2;1;1;2;3;4;1;2;|] + [|0;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;2;3;2;2;1;2;1;2;3;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;2;1;2;3;4;5;2;3;4;5;2;3;4;5;1;1;1;1;1;1;2;3;1;4;5;1;1;1;1;1;1;2;1;2;3;1;1;1;2;2;3;4;1;1;2;1;2;3;1;1;2;4;1;2;1;1;1;2;2;1;1;1;2;2;1;2;3;2;3;5;6;1;1;1;1;1;2;1;2;1;1;1;2;1;2;1;1;1;2;3;4;5;6;7;8;1;2;1;2;3;1;1;1;2;3;1;1;1;2;2;1;2;2;1;1;2;3;4;1;1;5;6;6;1;2;3;4;1;1;2;1;1;1;1;1;2;3;4;1;2;3;1;2;3;1;1;2;3;3;1;1;4;1;2;1;1;1;2;3;1;1;1;1;2;1;1;1;2;1;1;2;3;1;1;1;1;2;1;2;2;1;1;1;2;3;4;2;3;1;2;3;1;2;2;1;2;1;1;2;1;2;1;1;2;1;1;2;3;1;4;1;1;1;1;1;2;3;2;3;2;1;2;3;2;1;2;3;4;3;3;3;1;1;3;4;2;3;1;2;1;3;4;2;3;5;1;2;1;2;3;2;3;4;5;3;4;3;4;4;5;6;2;1;2;2;1;1;2;3;1;1;2;1;1;1;1;1;1;4;1;1;2;3;1;1;1;2;3;4;1;2;3;1;1;1;2;3;2;3;2;1;2;1;1;2;3;1;2;4;5;6;1;1;1;2;3;2;3;2;3;3;4;5;2;3;2;3;2;4;4;5;4;5;3;4;2;3;1;2;3;3;2;3;4;5;1;6;5;2;2;3;1;1;2;1;2;3;3;4;2;1;2;3;1;1;2;3;4;5;1;2;1;2;2;3;1;2;3;1;2;1;2;3;4;1;5;2;1;2;3;1;2;4;5;4;5;6;2;3;4;5;1;1;2;3;4;5;2;1;2;3;3;1;1;1;4;5;2;3;2;3;4;2;3;4;1;3;2;3;1;4;2;3;4;5;3;4;1;5;2;3;2;3;3;4;5;2;2;1;1;6;7;1;1;1;1;1;1;1;1;1;2;3;1;2;3;1;2;3;1;2;3;1;1;2;1;2;3;1;1;2;1;2;3;3;4;5;1;2;1;2;3;4;1;2;1;1;1;2;4;1;2;5;6;1;2;3;4;5;6;7;8;9;2;3;1;1;2;3;4;5;1;1;1;2;1;1;2;3;4;1;1;4;5;6;7;8;9;10;1;1;1;1;2;3;4;1;2;3;4;2;3;2;3;1;2;3;4;5;1;2;3;4;5;1;1;2;3;1;2;1;2;3;4;4;5;2;1;2;1;2;2;3;2;3;4;5;1;2;3;4;5;6;1;2;1;1;1;1;1;2;3;1;1;2;3;4;5;6;3;2;3;4;5;6;3;2;1;2;1;2;3;4;5;2;2;3;4;5;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;2;3;4;5;6;3;1;2;1;1;2;2;3;4;5;6;7;8;3;2;3;4;5;6;7;2;3;4;2;1;1;2;3;1;4;1;1;2;3;4;5;1;2;3;2;3;2;3;2;3;2;3;2;1;1;2;3;1;3;1;2;4;2;3;3;4;5;3;4;5;3;4;5;6;7;1;2;3;5;6;7;5;6;7;3;1;2;2;3;4;5;6;7;8;9;10;7;3;4;5;6;7;8;9;10;7;3;4;5;6;7;8;9;10;7;2;3;4;5;6;7;8;9;10;7;3;4;5;6;7;8;9;10;7;3;4;5;6;7;8;9;10;7;3;4;5;6;7;8;9;10;11;12;9;5;6;7;8;9;10;11;12;9;5;6;7;8;9;10;11;12;9;3;4;5;6;7;8;5;1;2;2;1;2;6;4;5;3;4;5;3;4;5;5;1;2;3;2;3;4;2;3;1;1;4;5;3;4;4;5;3;4;4;5;3;4;5;3;1;2;3;1;2;3;4;5;1;4;5;1;2;3;3;6;1;1;7;8;9;10;11;6;7;3;4;5;2;3;3;2;4;4;5;6;7;8;9;10;11;12;13;14;11;6;7;8;9;10;11;8;4;4;5;4;2;3;4;5;6;2;3;2;2;3;2;3;4;5;2;2;3;4;2;2;3;2;3;8;3;4;5;6;7;2;3;4;5;1;2;1;2;3;4;6;7;8;1;2;2;3;4;1;1;2;3;1;5;1;1;1;1;2;3;1;2;3;4;5;6;7;1;2;3;1;2;1;1;2;3;2;1;1;2;3;4;5;6;4;2;3;4;2;6;7;8;9;1;2;3;1;4;5;6;2;4;5;2;2;3;4;5;6;3;2;2;3;2;2;3;4;5;6;6;7;8;2;3;3;4;4;5;6;4;5;6;7;8;8;9;10;8;9;10;10;11;12;4;5;5;6;7;5;6;7;7;8;9;5;6;2;3;4;5;1;2;3;4;5;1;2;6;7;2;3;4;5;6;7;1;2;3;4;5;6;8;4;5;6;1;2;1;2;3;4;1;2;1;2;3;4;5;1;2;3;4;5;1;2;3;6;7;1;2;8;9;1;1;2;3;4;5;1;1;2;3;6;7;8;5;6;7;1;1;1;2;3;4;5;6;2;3;4;5;1;2;3;4;5;6;7;8;2;3;4;5;6;7;4;5;6;7;8;1;2;3;4;5;6;7;9;4;5;6;7;1;2;5;6;1;2;1;2;3;4;5;1;2;3;4;1;2;3;4;1;5;1;2;3;6;7;8;1;2;1;2;3;3;1;2;1;2;1;2;3;4;5;6;7;1;2;1;2;1;2;3;4;5;6;7;1;2;1;2;3;4;5;6;1;2;3;4;2;3;1;1;1;7;2;3;4;5;6;3;4;1;2;1;2;3;3;4;4;5;1;2;1;1;2;9;10;1;2;3;4;5;6;7;8;9;11;2;3;4;5;6;7;1;2;3;4;1;1;1;2;1;2;3;1;1;4;1;3;5;8;9;1;2;3;4;5;6;7;8;9;10;1;1;1;1;1;1;1;1;2;1;2;1;1;2;3;4;5;6;7;8;2;1;1;2;3;4;5;1;1;2;3;1;1;2;3;4;1;1;2;6;7;8;9;1;1;1;2;3;4;5;6;4;4;1;2;3;3;4;5;3;3;1;2;1;1;2;2;1;2;1;2;3;4;5;6;1;1;2;3;1;1;2;3;4;5;6;5;6;7;2;3;1;1;2;1;2;2;3;4;5;2;3;4;5;4;5;6;1;1;2;1;3;4;5;6;7;8;9;10;11;6;7;8;5;2;3;1;1;2;1;2;2;3;4;5;2;3;4;5;6;7;8;9;10;5;6;7;4;1;2;3;4;1;2;3;1;1;2;3;4;5;6;7;2;3;4;5;6;1;2;3;4;1;2;1;2;1;2;1;1;2;1;3;2;2;3;2;3;7;3;4;5;6;2;3;4;5;2;3;3;4;5;4;1;2;5;6;2;3;4;5;1;2;3;4;4;5;1;2;1;1;2;2;1;2;3;4;1;2;7;8;1;2;3;4;5;6;7;8;9;1;1;1;1;1;1;1;1;2;1;1;2;1;2;1;1;1;1;2;3;1;1;1;3;4;3;4;2;3;4;2;3;4;5;7;8;2;3;3;4;5;4;5;6;4;5;6;3;4;9;6;7;8;1;2;3;4;5;9;10;2;2;1;1;1;1;1;2;3;4;4;5;6;7;8;5;6;7;8;9;3;4;3;4;5;6;1;7;1;2;3;2;2;3;3;4;5;2;3;4;5;4;2;3;2;2;3;2;3;4;2;2;2;2;7;8;9;10;6;7;8;9;10;2;1;1;4;5;6;7;8;9;5;6;7;8;9;3;4;5;6;6;7;3;4;3;4;5;6;7;1;2;1;0;1;2;1;0;1;2;3;1;1;1;2;3;4;5;3;3;1;1;1;1;2;0;1;1;2;0;1;1;2;0;1;2;1;0;1;1;2;0;1;1;2;0;1;1;2;0;1;1;2;0;1;1;2;0;1;2;1;0;1;2;1;1;2;0;1;2;3;3;3;3;3;3;1;1;1;2;1;2;1;2;3;1;2;0;1;1;1;2;2;2;3;4;2;1;1;2;3;4;1;2;|] let can_pop (type a) : a terminal -> bool = function | T_WITH -> true - | T_WHILE_LWT -> true | T_WHILE -> true | T_WHEN -> true | T_VIRTUAL -> true | T_VAL -> true | T_UNDERSCORE -> true | T_TYPE -> true - | T_TRY_LWT -> true | T_TRY -> true | T_TRUE -> true | T_TO -> true @@ -424,10 +423,8 @@ let can_pop (type a) : a terminal -> bool = function | T_MINUSDOT -> true | T_MINUS -> true | T_METHOD -> true - | T_MATCH_LWT -> true | T_MATCH -> true | T_LPAREN -> true - | T_LET_LWT -> true | T_LET -> true | T_LESSMINUS -> true | T_LESS -> true @@ -456,9 +453,7 @@ let can_pop (type a) : a terminal -> bool = function | T_FUNCTOR -> true | T_FUNCTION -> true | T_FUN -> true - | T_FOR_LWT -> true | T_FOR -> true - | T_FINALLY_LWT -> true | T_FALSE -> true | T_EXTERNAL -> true | T_EXCEPTION -> true @@ -494,3065 +489,3326 @@ let can_pop (type a) : a terminal -> bool = function | _ -> false let recover = - let r0 = [R 585] in - let r1 = S (N N_expr) :: r0 in - let r2 = [R 127] in - let r3 = S (T T_DONE) :: r2 in - let r4 = Sub (r1) :: r3 in - let r5 = S (T T_DO) :: r4 in - let r6 = Sub (r1) :: r5 in - let r7 = R 282 :: r6 in - let r8 = [R 684] in - let r9 = S (T T_AND) :: r8 in - let r10 = [R 42] in - let r11 = Sub (r9) :: r10 in - let r12 = [R 188] in - let r13 = [R 43] in - let r14 = [R 506] in - let r15 = S (N N_structure) :: r14 in - let r16 = [R 44] in - let r17 = S (T T_RBRACKET) :: r16 in - let r18 = Sub (r15) :: r17 in - let r19 = [R 142] in - let r20 = S (T T_DONE) :: r19 in - let r21 = Sub (r1) :: r20 in - let r22 = S (T T_DO) :: r21 in - let r23 = Sub (r1) :: r22 in - let r24 = R 282 :: r23 in - let r25 = [R 652] in - let r26 = [R 346] in - let r27 = [R 123] in - let r28 = Sub (r1) :: r27 in - let r29 = R 282 :: r28 in - let r30 = [R 315] in - let r31 = Sub (r1) :: r30 in - let r32 = S (T T_MINUSGREATER) :: r31 in - let r33 = S (N N_pattern) :: r32 in - let r34 = [R 550] in - let r35 = Sub (r33) :: r34 in - let r36 = [R 139] in - let r37 = Sub (r35) :: r36 in - let r38 = S (T T_WITH) :: r37 in - let r39 = Sub (r1) :: r38 in - let r40 = R 282 :: r39 in - let r41 = [R 190] in - let r42 = S (T T_UNDERSCORE) :: r25 in - let r43 = [R 642] in - let r44 = [R 637] in - let r45 = S (T T_END) :: r44 in - let r46 = R 299 :: r45 in - let r47 = R 69 :: r46 in - let r48 = R 282 :: r47 in - let r49 = [R 67] in - let r50 = S (T T_RPAREN) :: r49 in - let r51 = [R 670] in - let r52 = [R 613] in - let r53 = [R 611] in - let r54 = [R 101] in - let r55 = [R 666] in - let r56 = S (T T_RPAREN) :: r55 in - let r57 = [R 441] in - let r58 = S (T T_AMPERAMPER) :: r57 in - let r59 = [R 798] in - let r60 = S (T T_RPAREN) :: r59 in - let r61 = Sub (r58) :: r60 in - let r62 = [R 368] in - let r63 = S (T T_UNDERSCORE) :: r62 in - let r64 = [R 668] in - let r65 = S (T T_RPAREN) :: r64 in - let r66 = Sub (r63) :: r65 in - let r67 = R 282 :: r66 in - let r68 = [R 669] in - let r69 = S (T T_RPAREN) :: r68 in - let r70 = [R 334] in - let r71 = [R 590] in - let r72 = R 290 :: r71 in - let r73 = [R 370] in - let r74 = S (T T_END) :: r73 in - let r75 = Sub (r72) :: r74 in - let r76 = [R 799] in - let r77 = S (T T_LIDENT) :: r76 in - let r78 = [R 25] in - let r79 = S (T T_UNDERSCORE) :: r78 in - let r80 = [R 772] in - let r81 = Sub (r79) :: r80 in - let r82 = [R 202] in - let r83 = Sub (r81) :: r82 in - let r84 = [R 17] in - let r85 = Sub (r83) :: r84 in - let r86 = [R 117] in - let r87 = Sub (r85) :: r86 in - let r88 = [R 511] in - let r89 = Sub (r87) :: r88 in - let r90 = [R 807] in - let r91 = R 288 :: r90 in - let r92 = Sub (r89) :: r91 in - let r93 = S (T T_COLON) :: r92 in - let r94 = Sub (r77) :: r93 in - let r95 = R 282 :: r94 in - let r96 = [R 415] in - let r97 = S (T T_RPAREN) :: r96 in - let r98 = R 224 :: r97 in - let r99 = [R 225] in - let r100 = [R 417] in - let r101 = S (T T_RBRACKET) :: r100 in - let r102 = [R 419] in - let r103 = S (T T_RBRACE) :: r102 in - let r104 = [R 222] in - let r105 = S (T T_LIDENT) :: r104 in - let r106 = [R 24] in - let r107 = Sub (r105) :: r106 in - let r108 = [R 548] in - let r109 = [R 464] in - let r110 = S (T T_COLON) :: r109 in - let r111 = [R 23] in - let r112 = S (T T_RPAREN) :: r111 in - let r113 = S (N N_module_type) :: r112 in - let r114 = R 282 :: r113 in - let r115 = R 187 :: r114 in - let r116 = [R 372] in - let r117 = S (N N_module_expr) :: r116 in - let r118 = R 282 :: r117 in - let r119 = S (T T_OF) :: r118 in - let r120 = [R 358] in - let r121 = S (T T_END) :: r120 in - let r122 = S (N N_structure) :: r121 in - let r123 = [R 332] in - let r124 = S (T T_LIDENT) :: r123 in - let r125 = [R 779] in - let r126 = Sub (r124) :: r125 in - let r127 = [R 102] in - let r128 = S (T T_FALSE) :: r127 in - let r129 = [R 106] in - let r130 = Sub (r128) :: r129 in - let r131 = [R 216] in - let r132 = R 282 :: r131 in - let r133 = R 209 :: r132 in - let r134 = Sub (r130) :: r133 in - let r135 = [R 531] in - let r136 = Sub (r134) :: r135 in - let r137 = [R 747] in - let r138 = R 288 :: r137 in - let r139 = Sub (r136) :: r138 in - let r140 = R 517 :: r139 in - let r141 = S (T T_PLUSEQ) :: r140 in - let r142 = Sub (r126) :: r141 in - let r143 = R 781 :: r142 in - let r144 = R 282 :: r143 in - let r145 = [R 219] in - let r146 = R 288 :: r145 in - let r147 = R 540 :: r146 in - let r148 = R 777 :: r147 in - let r149 = S (T T_LIDENT) :: r148 in - let r150 = R 781 :: r149 in - let r151 = R 282 :: r150 in - let r152 = R 187 :: r151 in - let r153 = [R 748] in - let r154 = R 288 :: r153 in - let r155 = Sub (r136) :: r154 in - let r156 = R 517 :: r155 in - let r157 = S (T T_PLUSEQ) :: r156 in - let r158 = Sub (r126) :: r157 in - let r159 = [R 220] in - let r160 = R 288 :: r159 in - let r161 = R 540 :: r160 in - let r162 = R 777 :: r161 in - let r163 = S (T T_LIDENT) :: r162 in - let r164 = R 781 :: r163 in - let r165 = [R 785] in - let r166 = S (T T_UNDERSCORE) :: r165 in - let r167 = [R 780] in - let r168 = Sub (r166) :: r167 in - let r169 = R 786 :: r168 in - let r170 = [R 561] in - let r171 = Sub (r169) :: r170 in - let r172 = [R 783] in - let r173 = S (T T_RPAREN) :: r172 in - let r174 = [R 784] in - let r175 = [R 562] in - let r176 = [R 400] in - let r177 = S (T T_DOTDOT) :: r176 in - let r178 = [R 778] in - let r179 = [R 401] in - let r180 = [R 105] in - let r181 = S (T T_RPAREN) :: r180 in - let r182 = [R 204] in - let r183 = Sub (r83) :: r182 in - let r184 = S (T T_MINUSGREATER) :: r183 in - let r185 = Sub (r81) :: r184 in - let r186 = [R 30] in - let r187 = [R 513] in - let r188 = Sub (r85) :: r187 in - let r189 = [R 322] in - let r190 = R 282 :: r189 in - let r191 = Sub (r188) :: r190 in - let r192 = [R 189] in - let r193 = S (T T_RBRACKET) :: r192 in - let r194 = Sub (r15) :: r193 in - let r195 = [R 294] in - let r196 = [R 408] in - let r197 = R 288 :: r196 in - let r198 = S (N N_module_expr) :: r197 in - let r199 = R 282 :: r198 in - let r200 = [R 409] in - let r201 = R 288 :: r200 in - let r202 = S (N N_module_expr) :: r201 in - let r203 = R 282 :: r202 in - let r204 = [R 466] in - let r205 = S (T T_RPAREN) :: r204 in - let r206 = [R 467] in - let r207 = S (T T_RPAREN) :: r206 in - let r208 = S (N N_expr) :: r207 in - let r209 = [R 344] in - let r210 = S (T T_LIDENT) :: r209 in - let r211 = [R 66] in - let r212 = Sub (r210) :: r211 in - let r213 = [R 634] in - let r214 = Sub (r212) :: r213 in - let r215 = R 282 :: r214 in - let r216 = [R 345] in - let r217 = S (T T_LIDENT) :: r216 in - let r218 = [R 347] in - let r219 = [R 352] in - let r220 = [R 283] in - let r221 = [R 122] in - let r222 = Sub (r35) :: r221 in - let r223 = S (T T_WITH) :: r222 in - let r224 = Sub (r1) :: r223 in - let r225 = R 282 :: r224 in - let r226 = [R 138] in - let r227 = Sub (r35) :: r226 in - let r228 = S (T T_WITH) :: r227 in - let r229 = Sub (r1) :: r228 in - let r230 = R 282 :: r229 in - let r231 = [R 621] in - let r232 = S (T T_RPAREN) :: r231 in - let r233 = [R 657] in - let r234 = [R 175] in - let r235 = [R 252] in - let r236 = Sub (r77) :: r235 in - let r237 = [R 312] in - let r238 = R 288 :: r237 in - let r239 = Sub (r236) :: r238 in - let r240 = R 524 :: r239 in - let r241 = R 282 :: r240 in - let r242 = [R 618] in - let r243 = [R 100] in - let r244 = [R 579] in - let r245 = S (N N_pattern) :: r244 in - let r246 = [R 616] in - let r247 = S (T T_RBRACKET) :: r246 in - let r248 = [R 236] in - let r249 = Sub (r210) :: r248 in - let r250 = [R 308] in - let r251 = R 457 :: r250 in - let r252 = R 451 :: r251 in - let r253 = Sub (r249) :: r252 in - let r254 = [R 615] in - let r255 = S (T T_RBRACE) :: r254 in - let r256 = [R 452] in - let r257 = [R 572] in - let r258 = Sub (r87) :: r257 in - let r259 = [R 557] in - let r260 = Sub (r258) :: r259 in - let r261 = [R 39] in - let r262 = S (T T_RBRACKET) :: r261 in - let r263 = Sub (r260) :: r262 in - let r264 = [R 38] in - let r265 = [R 37] in - let r266 = S (T T_RBRACKET) :: r265 in - let r267 = [R 389] in - let r268 = Sub (r105) :: r267 in - let r269 = S (T T_BACKQUOTE) :: r268 in - let r270 = [R 760] in - let r271 = R 282 :: r270 in + let r0 = [R 232] in + let r1 = S (N N_fun_expr) :: r0 in + let r2 = [R 635] in + let r3 = Sub (r1) :: r2 in + let r4 = [R 150] in + let r5 = S (T T_DONE) :: r4 in + let r6 = Sub (r3) :: r5 in + let r7 = S (T T_DO) :: r6 in + let r8 = Sub (r3) :: r7 in + let r9 = R 316 :: r8 in + let r10 = [R 733] in + let r11 = S (T T_AND) :: r10 in + let r12 = [R 32] in + let r13 = Sub (r11) :: r12 in + let r14 = [R 125] in + let r15 = [R 33] in + let r16 = [R 547] in + let r17 = S (N N_structure) :: r16 in + let r18 = [R 34] in + let r19 = Sub (r17) :: r18 in + let r20 = [R 35] in + let r21 = S (T T_RBRACKET) :: r20 in + let r22 = Sub (r19) :: r21 in + let r23 = [R 846] in + let r24 = S (T T_LIDENT) :: r23 in + let r25 = [R 31] in + let r26 = S (T T_UNDERSCORE) :: r25 in + let r27 = [R 819] in + let r28 = Sub (r26) :: r27 in + let r29 = [R 236] in + let r30 = Sub (r28) :: r29 in + let r31 = [R 17] in + let r32 = Sub (r30) :: r31 in + let r33 = [R 108] in + let r34 = Sub (r32) :: r33 in + let r35 = [R 552] in + let r36 = Sub (r34) :: r35 in + let r37 = [R 854] in + let r38 = R 322 :: r37 in + let r39 = Sub (r36) :: r38 in + let r40 = S (T T_COLON) :: r39 in + let r41 = Sub (r24) :: r40 in + let r42 = R 316 :: r41 in + let r43 = [R 475] in + let r44 = S (T T_AMPERAMPER) :: r43 in + let r45 = [R 845] in + let r46 = S (T T_RPAREN) :: r45 in + let r47 = Sub (r44) :: r46 in + let r48 = [R 449] in + let r49 = S (T T_RPAREN) :: r48 in + let r50 = R 258 :: r49 in + let r51 = [R 259] in + let r52 = [R 451] in + let r53 = S (T T_RBRACKET) :: r52 in + let r54 = [R 453] in + let r55 = S (T T_RBRACE) :: r54 in + let r56 = [R 365] in + let r57 = [R 127] in + let r58 = [R 256] in + let r59 = S (T T_LIDENT) :: r58 in + let r60 = [R 591] in + let r61 = [R 30] in + let r62 = Sub (r59) :: r61 in + let r63 = [R 501] in + let r64 = S (T T_COLON) :: r63 in + let r65 = [R 114] in + let r66 = S (T T_RPAREN) :: r65 in + let r67 = S (N N_module_type) :: r66 in + let r68 = R 316 :: r67 in + let r69 = R 124 :: r68 in + let r70 = [R 638] in + let r71 = R 324 :: r70 in + let r72 = [R 401] in + let r73 = S (T T_END) :: r72 in + let r74 = Sub (r71) :: r73 in + let r75 = [R 253] in + let r76 = R 322 :: r75 in + let r77 = R 581 :: r76 in + let r78 = R 824 :: r77 in + let r79 = S (T T_LIDENT) :: r78 in + let r80 = R 828 :: r79 in + let r81 = R 316 :: r80 in + let r82 = R 124 :: r81 in + let r83 = [R 363] in + let r84 = S (T T_LIDENT) :: r83 in + let r85 = [R 826] in + let r86 = Sub (r84) :: r85 in + let r87 = [R 93] in + let r88 = S (T T_FALSE) :: r87 in + let r89 = [R 97] in + let r90 = Sub (r88) :: r89 in + let r91 = [R 250] in + let r92 = R 316 :: r91 in + let r93 = R 243 :: r92 in + let r94 = Sub (r90) :: r93 in + let r95 = [R 578] in + let r96 = Sub (r94) :: r95 in + let r97 = [R 645] in + let r98 = R 322 :: r97 in + let r99 = Sub (r96) :: r98 in + let r100 = R 558 :: r99 in + let r101 = S (T T_PLUSEQ) :: r100 in + let r102 = Sub (r86) :: r101 in + let r103 = R 828 :: r102 in + let r104 = R 316 :: r103 in + let r105 = [R 254] in + let r106 = R 322 :: r105 in + let r107 = R 581 :: r106 in + let r108 = R 824 :: r107 in + let r109 = S (T T_LIDENT) :: r108 in + let r110 = R 828 :: r109 in + let r111 = [R 646] in + let r112 = R 322 :: r111 in + let r113 = Sub (r96) :: r112 in + let r114 = R 558 :: r113 in + let r115 = S (T T_PLUSEQ) :: r114 in + let r116 = Sub (r86) :: r115 in + let r117 = [R 832] in + let r118 = S (T T_UNDERSCORE) :: r117 in + let r119 = [R 827] in + let r120 = Sub (r118) :: r119 in + let r121 = R 833 :: r120 in + let r122 = [R 604] in + let r123 = Sub (r121) :: r122 in + let r124 = [R 830] in + let r125 = S (T T_RPAREN) :: r124 in + let r126 = [R 831] in + let r127 = [R 605] in + let r128 = [R 432] in + let r129 = S (T T_DOTDOT) :: r128 in + let r130 = [R 825] in + let r131 = [R 433] in + let r132 = [R 96] in + let r133 = S (T T_RPAREN) :: r132 in + let r134 = [R 92] in + let r135 = [R 238] in + let r136 = Sub (r30) :: r135 in + let r137 = S (T T_MINUSGREATER) :: r136 in + let r138 = Sub (r28) :: r137 in + let r139 = [R 441] in + let r140 = [R 554] in + let r141 = Sub (r32) :: r140 in + let r142 = [R 353] in + let r143 = R 316 :: r142 in + let r144 = Sub (r141) :: r143 in + let r145 = [R 126] in + let r146 = S (T T_RBRACKET) :: r145 in + let r147 = Sub (r17) :: r146 in + let r148 = [R 701] in + let r149 = [R 377] in + let r150 = [R 572] in + let r151 = Sub (r94) :: r150 in + let r152 = [R 794] in + let r153 = R 322 :: r152 in + let r154 = Sub (r151) :: r153 in + let r155 = R 558 :: r154 in + let r156 = S (T T_PLUSEQ) :: r155 in + let r157 = Sub (r86) :: r156 in + let r158 = R 828 :: r157 in + let r159 = R 316 :: r158 in + let r160 = [R 795] in + let r161 = R 322 :: r160 in + let r162 = Sub (r151) :: r161 in + let r163 = R 558 :: r162 in + let r164 = S (T T_PLUSEQ) :: r163 in + let r165 = Sub (r86) :: r164 in + let r166 = [R 556] in + let r167 = S (T T_RBRACKET) :: r166 in + let r168 = Sub (r19) :: r167 in + let r169 = [R 346] in + let r170 = Sub (r3) :: r169 in + let r171 = S (T T_MINUSGREATER) :: r170 in + let r172 = S (N N_pattern) :: r171 in + let r173 = [R 593] in + let r174 = Sub (r172) :: r173 in + let r175 = [R 143] in + let r176 = Sub (r174) :: r175 in + let r177 = S (T T_WITH) :: r176 in + let r178 = Sub (r3) :: r177 in + let r179 = R 316 :: r178 in + let r180 = S (T T_UNDERSCORE) :: r148 in + let r181 = [R 691] in + let r182 = [R 686] in + let r183 = S (T T_END) :: r182 in + let r184 = R 333 :: r183 in + let r185 = R 60 :: r184 in + let r186 = R 316 :: r185 in + let r187 = [R 58] in + let r188 = S (T T_RPAREN) :: r187 in + let r189 = [R 719] in + let r190 = [R 661] in + let r191 = [R 659] in + let r192 = [R 715] in + let r193 = S (T T_RPAREN) :: r192 in + let r194 = [R 399] in + let r195 = S (T T_UNDERSCORE) :: r194 in + let r196 = [R 717] in + let r197 = S (T T_RPAREN) :: r196 in + let r198 = Sub (r195) :: r197 in + let r199 = R 316 :: r198 in + let r200 = [R 718] in + let r201 = S (T T_RPAREN) :: r200 in + let r202 = [R 403] in + let r203 = S (N N_module_expr) :: r202 in + let r204 = R 316 :: r203 in + let r205 = S (T T_OF) :: r204 in + let r206 = [R 389] in + let r207 = S (T T_END) :: r206 in + let r208 = S (N N_structure) :: r207 in + let r209 = [R 328] in + let r210 = [R 442] in + let r211 = R 322 :: r210 in + let r212 = S (N N_module_expr) :: r211 in + let r213 = R 316 :: r212 in + let r214 = [R 443] in + let r215 = R 322 :: r214 in + let r216 = S (N N_module_expr) :: r215 in + let r217 = R 316 :: r216 in + let r218 = [R 503] in + let r219 = S (T T_RPAREN) :: r218 in + let r220 = [R 504] in + let r221 = S (T T_RPAREN) :: r220 in + let r222 = S (N N_fun_expr) :: r221 in + let r223 = [R 375] in + let r224 = S (T T_LIDENT) :: r223 in + let r225 = [R 57] in + let r226 = Sub (r224) :: r225 in + let r227 = [R 683] in + let r228 = Sub (r226) :: r227 in + let r229 = R 316 :: r228 in + let r230 = [R 376] in + let r231 = S (T T_LIDENT) :: r230 in + let r232 = [R 378] in + let r233 = [R 383] in + let r234 = [R 317] in + let r235 = [R 142] in + let r236 = Sub (r174) :: r235 in + let r237 = S (T T_WITH) :: r236 in + let r238 = Sub (r3) :: r237 in + let r239 = R 316 :: r238 in + let r240 = [R 670] in + let r241 = S (T T_RPAREN) :: r240 in + let r242 = [R 706] in + let r243 = [R 206] in + let r244 = [R 301] in + let r245 = Sub (r24) :: r244 in + let r246 = [R 304] in + let r247 = Sub (r245) :: r246 in + let r248 = [R 203] in + let r249 = Sub (r3) :: r248 in + let r250 = S (T T_IN) :: r249 in + let r251 = [R 666] in + let r252 = [R 91] in + let r253 = [R 629] in + let r254 = S (N N_pattern) :: r253 in + let r255 = [R 664] in + let r256 = S (T T_RBRACKET) :: r255 in + let r257 = [R 270] in + let r258 = Sub (r224) :: r257 in + let r259 = [R 342] in + let r260 = R 494 :: r259 in + let r261 = R 487 :: r260 in + let r262 = Sub (r258) :: r261 in + let r263 = [R 663] in + let r264 = S (T T_RBRACE) :: r263 in + let r265 = [R 488] in + let r266 = [R 619] in + let r267 = Sub (r34) :: r266 in + let r268 = [R 600] in + let r269 = Sub (r267) :: r268 in + let r270 = [R 120] in + let r271 = S (T T_RBRACKET) :: r270 in let r272 = Sub (r269) :: r271 in - let r273 = [R 34] in + let r273 = [R 119] in let r274 = S (T T_RBRACKET) :: r273 in - let r275 = [R 95] in - let r276 = Sub (r124) :: r275 in - let r277 = [R 31] in - let r278 = [R 335] in - let r279 = S (T T_UIDENT) :: r278 in - let r280 = S (T T_DOT) :: r279 in - let r281 = [R 333] in - let r282 = S (T T_LIDENT) :: r281 in - let r283 = S (T T_UIDENT) :: r70 in - let r284 = [R 350] in - let r285 = Sub (r283) :: r284 in - let r286 = [R 351] in - let r287 = S (T T_RPAREN) :: r286 in - let r288 = [R 35] in - let r289 = S (T T_RBRACKET) :: r288 in - let r290 = [R 205] in - let r291 = [R 569] in - let r292 = [R 32] in - let r293 = [R 203] in - let r294 = Sub (r83) :: r293 in - let r295 = S (T T_MINUSGREATER) :: r294 in - let r296 = [R 570] in - let r297 = [R 558] in - let r298 = [R 553] in - let r299 = Sub (r85) :: r298 in - let r300 = [R 759] in - let r301 = R 282 :: r300 in - let r302 = Sub (r299) :: r301 in - let r303 = [R 554] in - let r304 = [R 18] in - let r305 = Sub (r105) :: r304 in - let r306 = [R 36] in - let r307 = S (T T_RBRACKET) :: r306 in - let r308 = Sub (r260) :: r307 in - let r309 = [R 546] in - let r310 = Sub (r269) :: r309 in - let r311 = [R 40] in - let r312 = S (T T_RBRACKET) :: r311 in - let r313 = [R 458] in - let r314 = S (T T_UNDERSCORE) :: r51 in - let r315 = [R 665] in - let r316 = Sub (r314) :: r315 in - let r317 = [R 497] in - let r318 = Sub (r316) :: r317 in - let r319 = R 282 :: r318 in - let r320 = [R 96] in - let r321 = [R 675] in - let r322 = S (T T_INT) :: r320 in - let r323 = [R 610] in - let r324 = Sub (r322) :: r323 in - let r325 = [R 672] in - let r326 = [R 677] in + let r275 = [R 118] in + let r276 = S (T T_RBRACKET) :: r275 in + let r277 = [R 421] in + let r278 = Sub (r59) :: r277 in + let r279 = S (T T_BACKQUOTE) :: r278 in + let r280 = [R 807] in + let r281 = R 316 :: r280 in + let r282 = Sub (r279) :: r281 in + let r283 = [R 115] in + let r284 = S (T T_RBRACKET) :: r283 in + let r285 = [R 86] in + let r286 = Sub (r84) :: r285 in + let r287 = [R 26] in + let r288 = [R 364] in + let r289 = S (T T_LIDENT) :: r288 in + let r290 = S (T T_DOT) :: r289 in + let r291 = S (T T_UIDENT) :: r56 in + let r292 = [R 381] in + let r293 = Sub (r291) :: r292 in + let r294 = [R 382] in + let r295 = S (T T_RPAREN) :: r294 in + let r296 = [R 366] in + let r297 = S (T T_UIDENT) :: r296 in + let r298 = [R 116] in + let r299 = S (T T_RBRACKET) :: r298 in + let r300 = [R 239] in + let r301 = [R 616] in + let r302 = S (T T_DOT) :: r297 in + let r303 = S (T T_LBRACKETGREATER) :: r274 in + let r304 = [R 29] in + let r305 = Sub (r303) :: r304 in + let r306 = [R 237] in + let r307 = Sub (r30) :: r306 in + let r308 = S (T T_MINUSGREATER) :: r307 in + let r309 = [R 617] in + let r310 = [R 27] in + let r311 = [R 113] in + let r312 = [R 18] in + let r313 = Sub (r59) :: r312 in + let r314 = [R 601] in + let r315 = [R 596] in + let r316 = Sub (r32) :: r315 in + let r317 = [R 806] in + let r318 = R 316 :: r317 in + let r319 = Sub (r316) :: r318 in + let r320 = [R 597] in + let r321 = [R 117] in + let r322 = S (T T_RBRACKET) :: r321 in + let r323 = Sub (r269) :: r322 in + let r324 = [R 589] in + let r325 = Sub (r279) :: r324 in + let r326 = [R 121] in let r327 = S (T T_RBRACKET) :: r326 in - let r328 = S (T T_LBRACKET) :: r327 in - let r329 = [R 678] in - let r330 = [R 488] in - let r331 = S (N N_pattern) :: r330 in - let r332 = R 282 :: r331 in - let r333 = [R 489] in - let r334 = [R 482] in - let r335 = [R 496] in - let r336 = [R 494] in - let r337 = [R 390] in - let r338 = S (T T_LIDENT) :: r337 in - let r339 = [R 495] in - let r340 = Sub (r316) :: r339 in - let r341 = S (T T_RPAREN) :: r340 in - let r342 = [R 110] in - let r343 = [R 109] in - let r344 = S (T T_RPAREN) :: r343 in - let r345 = [R 490] in - let r346 = [R 680] in - let r347 = S (T T_RPAREN) :: r346 in - let r348 = [R 487] in - let r349 = [R 485] in - let r350 = [R 108] in - let r351 = S (T T_RPAREN) :: r350 in - let r352 = [R 679] in - let r353 = [R 310] in - let r354 = [R 617] in - let r355 = [R 248] in - let r356 = [R 234] in - let r357 = S (T T_LIDENT) :: r356 in - let r358 = [R 247] in + let r328 = [R 495] in + let r329 = S (T T_UNDERSCORE) :: r189 in + let r330 = [R 714] in + let r331 = Sub (r329) :: r330 in + let r332 = [R 538] in + let r333 = Sub (r331) :: r332 in + let r334 = R 316 :: r333 in + let r335 = [R 87] in + let r336 = [R 724] in + let r337 = S (T T_INT) :: r335 in + let r338 = [R 658] in + let r339 = Sub (r337) :: r338 in + let r340 = [R 721] in + let r341 = [R 726] in + let r342 = S (T T_RBRACKET) :: r341 in + let r343 = S (T T_LBRACKET) :: r342 in + let r344 = [R 727] in + let r345 = [R 529] in + let r346 = S (N N_pattern) :: r345 in + let r347 = R 316 :: r346 in + let r348 = [R 530] in + let r349 = [R 523] in + let r350 = [R 537] in + let r351 = [R 535] in + let r352 = [R 422] in + let r353 = S (T T_LIDENT) :: r352 in + let r354 = [R 536] in + let r355 = Sub (r331) :: r354 in + let r356 = S (T T_RPAREN) :: r355 in + let r357 = [R 101] in + let r358 = [R 100] in let r359 = S (T T_RPAREN) :: r358 in - let r360 = [R 235] in - let r361 = [R 244] in - let r362 = [R 243] in - let r363 = S (T T_RPAREN) :: r362 in - let r364 = R 459 :: r363 in - let r365 = [R 460] in - let r366 = [R 267] in - let r367 = Sub (r77) :: r366 in - let r368 = [R 270] in - let r369 = Sub (r367) :: r368 in - let r370 = [R 173] in - let r371 = Sub (r1) :: r370 in - let r372 = S (T T_IN) :: r371 in - let r373 = [R 505] in - let r374 = S (T T_UNDERSCORE) :: r373 in - let r375 = [R 246] in - let r376 = [R 245] in - let r377 = S (T T_RPAREN) :: r376 in - let r378 = R 459 :: r377 in - let r379 = [R 265] in - let r380 = [R 735] in - let r381 = Sub (r1) :: r380 in - let r382 = S (T T_EQUAL) :: r381 in - let r383 = [R 196] in - let r384 = Sub (r382) :: r383 in - let r385 = [R 737] in - let r386 = Sub (r384) :: r385 in - let r387 = S (T T_RPAREN) :: r386 in - let r388 = Sub (r338) :: r387 in - let r389 = [R 249] in - let r390 = [R 133] in - let r391 = Sub (r1) :: r390 in - let r392 = S (T T_IN) :: r391 in - let r393 = S (N N_module_expr) :: r392 in - let r394 = R 282 :: r393 in - let r395 = R 187 :: r394 in - let r396 = [R 259] in - let r397 = R 288 :: r396 in - let r398 = Sub (r236) :: r397 in - let r399 = R 524 :: r398 in - let r400 = R 282 :: r399 in - let r401 = R 187 :: r400 in - let r402 = [R 134] in - let r403 = Sub (r1) :: r402 in - let r404 = S (T T_IN) :: r403 in - let r405 = S (N N_module_expr) :: r404 in - let r406 = R 282 :: r405 in - let r407 = [R 359] in - let r408 = S (N N_module_expr) :: r407 in - let r409 = S (T T_MINUSGREATER) :: r408 in - let r410 = S (N N_functor_args) :: r409 in - let r411 = [R 206] in - let r412 = [R 207] in - let r413 = S (T T_RPAREN) :: r412 in - let r414 = S (N N_module_type) :: r413 in - let r415 = [R 373] in - let r416 = S (T T_RPAREN) :: r415 in - let r417 = [R 371] in - let r418 = S (N N_module_type) :: r417 in - let r419 = S (T T_MINUSGREATER) :: r418 in - let r420 = S (N N_functor_args) :: r419 in - let r421 = [R 342] in - let r422 = Sub (r105) :: r421 in - let r423 = [R 381] in - let r424 = Sub (r422) :: r423 in - let r425 = [R 820] in - let r426 = S (N N_module_type) :: r425 in - let r427 = S (T T_EQUAL) :: r426 in - let r428 = Sub (r424) :: r427 in - let r429 = S (T T_TYPE) :: r428 in - let r430 = S (T T_MODULE) :: r429 in - let r431 = [R 555] in - let r432 = Sub (r430) :: r431 in - let r433 = [R 377] in - let r434 = [R 817] in - let r435 = Sub (r85) :: r434 in - let r436 = S (T T_COLONEQUAL) :: r435 in - let r437 = Sub (r249) :: r436 in - let r438 = [R 816] in - let r439 = R 540 :: r438 in - let r440 = [R 541] in - let r441 = Sub (r87) :: r440 in - let r442 = S (T T_EQUAL) :: r441 in - let r443 = [R 343] in - let r444 = Sub (r105) :: r443 in - let r445 = [R 821] in - let r446 = [R 376] in - let r447 = [R 818] in - let r448 = Sub (r285) :: r447 in - let r449 = S (T T_UIDENT) :: r218 in - let r450 = [R 819] in - let r451 = [R 556] in - let r452 = [R 364] in - let r453 = [R 465] in - let r454 = S (T T_RPAREN) :: r453 in - let r455 = [R 573] in - let r456 = S (N N_expr) :: r455 in - let r457 = [R 660] in - let r458 = S (T T_RBRACKET) :: r457 in - let r459 = [R 645] in - let r460 = [R 576] in - let r461 = R 453 :: r460 in - let r462 = [R 454] in - let r463 = [R 582] in - let r464 = R 453 :: r463 in - let r465 = R 461 :: r464 in - let r466 = Sub (r249) :: r465 in - let r467 = [R 526] in - let r468 = Sub (r466) :: r467 in - let r469 = [R 654] in - let r470 = S (T T_RBRACE) :: r469 in - let r471 = [R 620] in - let r472 = [R 619] in - let r473 = S (T T_GREATERDOT) :: r472 in - let r474 = [R 145] in - let r475 = Sub (r42) :: r474 in - let r476 = R 282 :: r475 in - let r477 = [R 633] in - let r478 = S (T T_END) :: r477 in - let r479 = R 282 :: r478 in - let r480 = [R 141] in - let r481 = S (N N_expr) :: r480 in - let r482 = S (T T_THEN) :: r481 in - let r483 = Sub (r1) :: r482 in - let r484 = R 282 :: r483 in - let r485 = [R 135] in - let r486 = Sub (r35) :: r485 in - let r487 = R 282 :: r486 in - let r488 = [R 551] in - let r489 = [R 316] in - let r490 = Sub (r1) :: r489 in - let r491 = S (T T_MINUSGREATER) :: r490 in - let r492 = [R 250] in - let r493 = Sub (r316) :: r492 in - let r494 = [R 198] in - let r495 = Sub (r1) :: r494 in - let r496 = S (T T_MINUSGREATER) :: r495 in - let r497 = [R 136] in + let r360 = [R 531] in + let r361 = [R 729] in + let r362 = S (T T_RPAREN) :: r361 in + let r363 = [R 528] in + let r364 = [R 526] in + let r365 = [R 99] in + let r366 = S (T T_RPAREN) :: r365 in + let r367 = [R 728] in + let r368 = [R 344] in + let r369 = [R 665] in + let r370 = [R 282] in + let r371 = [R 268] in + let r372 = S (T T_LIDENT) :: r371 in + let r373 = [R 281] in + let r374 = S (T T_RPAREN) :: r373 in + let r375 = [R 269] in + let r376 = [R 278] in + let r377 = [R 277] in + let r378 = S (T T_RPAREN) :: r377 in + let r379 = R 496 :: r378 in + let r380 = [R 497] in + let r381 = [R 139] in + let r382 = Sub (r3) :: r381 in + let r383 = S (T T_IN) :: r382 in + let r384 = S (N N_module_expr) :: r383 in + let r385 = R 316 :: r384 in + let r386 = R 124 :: r385 in + let r387 = [R 286] in + let r388 = Sub (r24) :: r387 in + let r389 = [R 293] in + let r390 = R 322 :: r389 in + let r391 = Sub (r388) :: r390 in + let r392 = R 565 :: r391 in + let r393 = R 316 :: r392 in + let r394 = R 124 :: r393 in + let r395 = [R 140] in + let r396 = Sub (r3) :: r395 in + let r397 = S (T T_IN) :: r396 in + let r398 = S (N N_module_expr) :: r397 in + let r399 = R 316 :: r398 in + let r400 = [R 390] in + let r401 = S (N N_module_expr) :: r400 in + let r402 = S (T T_MINUSGREATER) :: r401 in + let r403 = S (N N_functor_args) :: r402 in + let r404 = [R 240] in + let r405 = [R 241] in + let r406 = S (T T_RPAREN) :: r405 in + let r407 = S (N N_module_type) :: r406 in + let r408 = [R 404] in + let r409 = S (T T_RPAREN) :: r408 in + let r410 = [R 407] in + let r411 = S (N N_module_type) :: r410 in + let r412 = [R 402] in + let r413 = S (N N_module_type) :: r412 in + let r414 = S (T T_MINUSGREATER) :: r413 in + let r415 = S (N N_functor_args) :: r414 in + let r416 = [R 373] in + let r417 = Sub (r59) :: r416 in + let r418 = [R 413] in + let r419 = Sub (r417) :: r418 in + let r420 = [R 867] in + let r421 = S (N N_module_type) :: r420 in + let r422 = S (T T_EQUAL) :: r421 in + let r423 = Sub (r419) :: r422 in + let r424 = S (T T_TYPE) :: r423 in + let r425 = S (T T_MODULE) :: r424 in + let r426 = [R 598] in + let r427 = Sub (r425) :: r426 in + let r428 = [R 409] in + let r429 = [R 864] in + let r430 = Sub (r32) :: r429 in + let r431 = S (T T_COLONEQUAL) :: r430 in + let r432 = Sub (r258) :: r431 in + let r433 = [R 863] in + let r434 = R 581 :: r433 in + let r435 = [R 582] in + let r436 = Sub (r34) :: r435 in + let r437 = S (T T_EQUAL) :: r436 in + let r438 = [R 374] in + let r439 = Sub (r59) :: r438 in + let r440 = [R 868] in + let r441 = [R 408] in + let r442 = [R 865] in + let r443 = Sub (r293) :: r442 in + let r444 = S (T T_UIDENT) :: r232 in + let r445 = [R 866] in + let r446 = [R 599] in + let r447 = [R 395] in + let r448 = [R 502] in + let r449 = S (T T_RPAREN) :: r448 in + let r450 = [R 620] in + let r451 = S (N N_fun_expr) :: r450 in + let r452 = [R 709] in + let r453 = S (T T_RBRACKET) :: r452 in + let r454 = [R 694] in + let r455 = [R 626] in + let r456 = R 489 :: r455 in + let r457 = [R 490] in + let r458 = [R 632] in + let r459 = R 489 :: r458 in + let r460 = R 498 :: r459 in + let r461 = Sub (r258) :: r460 in + let r462 = [R 567] in + let r463 = Sub (r461) :: r462 in + let r464 = [R 703] in + let r465 = S (T T_RBRACE) :: r464 in + let r466 = [R 669] in + let r467 = [R 667] in + let r468 = S (T T_GREATERDOT) :: r467 in + let r469 = [R 153] in + let r470 = Sub (r180) :: r469 in + let r471 = R 316 :: r470 in + let r472 = [R 682] in + let r473 = S (T T_END) :: r472 in + let r474 = R 316 :: r473 in + let r475 = [R 148] in + let r476 = S (N N_fun_expr) :: r475 in + let r477 = S (T T_THEN) :: r476 in + let r478 = Sub (r3) :: r477 in + let r479 = R 316 :: r478 in + let r480 = [R 636] in + let r481 = Sub (r174) :: r480 in + let r482 = R 316 :: r481 in + let r483 = [R 594] in + let r484 = [R 347] in + let r485 = Sub (r3) :: r484 in + let r486 = S (T T_MINUSGREATER) :: r485 in + let r487 = [R 284] in + let r488 = Sub (r331) :: r487 in + let r489 = [R 230] in + let r490 = Sub (r488) :: r489 in + let r491 = [R 583] in + let r492 = Sub (r490) :: r491 in + let r493 = [R 231] in + let r494 = Sub (r492) :: r493 in + let r495 = [R 135] in + let r496 = Sub (r1) :: r495 in + let r497 = [R 141] in let r498 = Sub (r496) :: r497 in - let r499 = Sub (r493) :: r498 in - let r500 = R 282 :: r499 in - let r501 = [R 137] in - let r502 = Sub (r496) :: r501 in - let r503 = S (T T_RPAREN) :: r502 in - let r504 = [R 129] in - let r505 = S (T T_DONE) :: r504 in - let r506 = Sub (r1) :: r505 in - let r507 = S (T T_DO) :: r506 in - let r508 = Sub (r1) :: r507 in - let r509 = S (T T_IN) :: r508 in - let r510 = S (N N_pattern) :: r509 in - let r511 = R 282 :: r510 in - let r512 = [R 120] in - let r513 = S (T T_DOWNTO) :: r512 in - let r514 = [R 143] in - let r515 = S (T T_DONE) :: r514 in - let r516 = Sub (r1) :: r515 in - let r517 = S (T T_DO) :: r516 in - let r518 = Sub (r1) :: r517 in - let r519 = Sub (r513) :: r518 in - let r520 = Sub (r1) :: r519 in - let r521 = S (T T_EQUAL) :: r520 in - let r522 = S (N N_pattern) :: r521 in - let r523 = R 282 :: r522 in - let r524 = [R 643] in - let r525 = [R 653] in - let r526 = S (T T_RPAREN) :: r525 in - let r527 = S (T T_LPAREN) :: r526 in - let r528 = S (T T_DOT) :: r527 in - let r529 = [R 663] in - let r530 = S (T T_RPAREN) :: r529 in - let r531 = S (N N_module_type) :: r530 in - let r532 = S (T T_COLON) :: r531 in - let r533 = S (N N_module_expr) :: r532 in - let r534 = R 282 :: r533 in - let r535 = [R 268] in - let r536 = Sub (r1) :: r535 in - let r537 = S (T T_EQUAL) :: r536 in - let r538 = [R 144] in - let r539 = Sub (r42) :: r538 in - let r540 = R 282 :: r539 in - let r541 = [R 650] in - let r542 = [R 626] in - let r543 = S (T T_RPAREN) :: r542 in - let r544 = Sub (r456) :: r543 in - let r545 = S (T T_LPAREN) :: r544 in - let r546 = [R 170] in - let r547 = [R 239] in - let r548 = [R 774] in - let r549 = Sub (r87) :: r548 in - let r550 = S (T T_COLON) :: r549 in - let r551 = [R 240] in - let r552 = S (T T_RPAREN) :: r551 in - let r553 = Sub (r550) :: r552 in - let r554 = [R 776] in - let r555 = [R 775] in - let r556 = [R 241] in - let r557 = [R 242] in - let r558 = [R 649] in - let r559 = [R 623] in - let r560 = S (T T_RPAREN) :: r559 in - let r561 = Sub (r1) :: r560 in - let r562 = S (T T_LPAREN) :: r561 in - let r563 = [R 567] in - let r564 = [R 121] in - let r565 = Sub (r1) :: r564 in - let r566 = [R 172] in - let r567 = Sub (r1) :: r566 in - let r568 = [R 160] in - let r569 = [R 154] in - let r570 = [R 171] in - let r571 = [R 588] in - let r572 = Sub (r1) :: r571 in - let r573 = [R 157] in - let r574 = [R 161] in - let r575 = [R 153] in - let r576 = [R 156] in - let r577 = [R 155] in - let r578 = [R 165] in - let r579 = [R 159] in - let r580 = [R 158] in - let r581 = [R 163] in - let r582 = [R 152] in - let r583 = [R 151] in - let r584 = [R 174] in - let r585 = [R 150] in - let r586 = [R 164] in - let r587 = [R 162] in - let r588 = [R 166] in - let r589 = [R 167] in - let r590 = [R 168] in - let r591 = [R 568] in - let r592 = [R 169] in - let r593 = [R 19] in - let r594 = R 288 :: r593 in - let r595 = Sub (r236) :: r594 in - let r596 = [R 258] in - let r597 = Sub (r1) :: r596 in - let r598 = S (T T_EQUAL) :: r597 in - let r599 = [R 257] in - let r600 = Sub (r1) :: r599 in - let r601 = [R 492] in - let r602 = [R 498] in - let r603 = [R 503] in - let r604 = [R 501] in - let r605 = [R 491] in - let r606 = [R 515] in - let r607 = S (T T_RBRACKET) :: r606 in - let r608 = Sub (r15) :: r607 in - let r609 = [R 509] in - let r610 = [R 510] in - let r611 = [R 353] in - let r612 = S (N N_module_expr) :: r611 in - let r613 = S (T T_EQUAL) :: r612 in - let r614 = [R 750] in - let r615 = R 288 :: r614 in - let r616 = Sub (r613) :: r615 in - let r617 = Sub (r63) :: r616 in - let r618 = R 282 :: r617 in - let r619 = [R 379] in - let r620 = R 288 :: r619 in - let r621 = R 455 :: r620 in - let r622 = Sub (r105) :: r621 in - let r623 = R 282 :: r622 in - let r624 = R 187 :: r623 in - let r625 = [R 456] in - let r626 = [R 289] in - let r627 = [R 751] in - let r628 = R 278 :: r627 in - let r629 = R 288 :: r628 in - let r630 = Sub (r613) :: r629 in - let r631 = [R 354] in - let r632 = S (N N_module_expr) :: r631 in - let r633 = S (T T_EQUAL) :: r632 in - let r634 = [R 279] in - let r635 = R 278 :: r634 in - let r636 = R 288 :: r635 in - let r637 = Sub (r613) :: r636 in - let r638 = Sub (r63) :: r637 in - let r639 = [R 355] in - let r640 = [R 227] in - let r641 = S (T T_RBRACKET) :: r640 in - let r642 = Sub (r15) :: r641 in - let r643 = [R 193] in - let r644 = S (T T_RBRACKET) :: r643 in - let r645 = Sub (r15) :: r644 in - let r646 = [R 756] in - let r647 = R 288 :: r646 in - let r648 = S (N N_module_expr) :: r647 in - let r649 = R 282 :: r648 in - let r650 = [R 392] in - let r651 = S (T T_STRING) :: r650 in - let r652 = [R 516] in - let r653 = R 288 :: r652 in - let r654 = Sub (r651) :: r653 in - let r655 = S (T T_EQUAL) :: r654 in - let r656 = Sub (r89) :: r655 in - let r657 = S (T T_COLON) :: r656 in - let r658 = Sub (r77) :: r657 in - let r659 = R 282 :: r658 in - let r660 = [R 512] in - let r661 = Sub (r87) :: r660 in - let r662 = [R 549] in - let r663 = Sub (r128) :: r342 in - let r664 = [R 734] in - let r665 = R 288 :: r664 in - let r666 = R 282 :: r665 in - let r667 = Sub (r663) :: r666 in - let r668 = S (T T_EQUAL) :: r667 in - let r669 = Sub (r130) :: r668 in - let r670 = R 282 :: r669 in - let r671 = [R 589] in - let r672 = R 288 :: r671 in - let r673 = R 282 :: r672 in - let r674 = R 209 :: r673 in - let r675 = Sub (r130) :: r674 in - let r676 = R 282 :: r675 in - let r677 = R 187 :: r676 in - let r678 = [R 112] in - let r679 = Sub (r79) :: r678 in - let r680 = [R 210] in - let r681 = [R 229] in - let r682 = R 282 :: r681 in - let r683 = Sub (r188) :: r682 in - let r684 = S (T T_COLON) :: r683 in - let r685 = S (T T_LIDENT) :: r684 in - let r686 = R 382 :: r685 in - let r687 = [R 231] in - let r688 = Sub (r686) :: r687 in - let r689 = [R 114] in - let r690 = S (T T_RBRACE) :: r689 in - let r691 = [R 230] in - let r692 = R 282 :: r691 in - let r693 = S (T T_SEMI) :: r692 in - let r694 = R 282 :: r693 in - let r695 = Sub (r188) :: r694 in - let r696 = S (T T_COLON) :: r695 in - let r697 = [R 514] in - let r698 = Sub (r85) :: r697 in - let r699 = [R 113] in - let r700 = Sub (r79) :: r699 in - let r701 = S (T T_COLONCOLON) :: r351 in - let r702 = [R 213] in - let r703 = [R 214] in - let r704 = Sub (r79) :: r703 in - let r705 = [R 212] in - let r706 = Sub (r79) :: r705 in - let r707 = [R 211] in - let r708 = Sub (r79) :: r707 in - let r709 = [R 507] in - let r710 = [R 537] in - let r711 = Sub (r134) :: r710 in - let r712 = [R 597] in - let r713 = R 288 :: r712 in - let r714 = Sub (r711) :: r713 in - let r715 = R 517 :: r714 in - let r716 = S (T T_PLUSEQ) :: r715 in - let r717 = Sub (r126) :: r716 in - let r718 = R 781 :: r717 in - let r719 = R 282 :: r718 in - let r720 = [R 598] in - let r721 = R 288 :: r720 in - let r722 = Sub (r711) :: r721 in - let r723 = R 517 :: r722 in - let r724 = S (T T_PLUSEQ) :: r723 in - let r725 = Sub (r126) :: r724 in - let r726 = [R 218] in - let r727 = R 288 :: r726 in - let r728 = R 540 :: r727 in - let r729 = [R 404] in - let r730 = S (T T_RBRACE) :: r729 in - let r731 = [R 215] in - let r732 = R 282 :: r731 in - let r733 = R 209 :: r732 in - let r734 = Sub (r130) :: r733 in - let r735 = [R 402] in - let r736 = [R 403] in - let r737 = [R 407] in - let r738 = S (T T_RBRACE) :: r737 in - let r739 = [R 406] in - let r740 = S (T T_RBRACE) :: r739 in - let r741 = [R 217] in - let r742 = R 288 :: r741 in - let r743 = R 540 :: r742 in - let r744 = [R 291] in - let r745 = [R 410] in - let r746 = R 288 :: r745 in - let r747 = Sub (r285) :: r746 in - let r748 = R 282 :: r747 in - let r749 = [R 411] in - let r750 = R 288 :: r749 in - let r751 = Sub (r285) :: r750 in - let r752 = R 282 :: r751 in - let r753 = [R 356] in - let r754 = S (N N_module_type) :: r753 in - let r755 = S (T T_COLON) :: r754 in - let r756 = [R 600] in - let r757 = R 288 :: r756 in - let r758 = Sub (r755) :: r757 in - let r759 = Sub (r63) :: r758 in - let r760 = R 282 :: r759 in - let r761 = [R 380] in - let r762 = R 288 :: r761 in - let r763 = S (N N_module_type) :: r762 in - let r764 = S (T T_COLONEQUAL) :: r763 in - let r765 = Sub (r105) :: r764 in - let r766 = R 282 :: r765 in - let r767 = [R 369] in - let r768 = R 288 :: r767 in - let r769 = [R 603] in - let r770 = R 280 :: r769 in - let r771 = R 288 :: r770 in - let r772 = S (N N_module_type) :: r771 in - let r773 = S (T T_COLON) :: r772 in - let r774 = [R 281] in - let r775 = R 280 :: r774 in - let r776 = R 288 :: r775 in - let r777 = S (N N_module_type) :: r776 in - let r778 = S (T T_COLON) :: r777 in - let r779 = Sub (r63) :: r778 in - let r780 = S (T T_UIDENT) :: r26 in - let r781 = Sub (r780) :: r219 in - let r782 = [R 601] in - let r783 = R 288 :: r782 in - let r784 = [R 357] in - let r785 = [R 607] in - let r786 = R 288 :: r785 in - let r787 = S (N N_module_type) :: r786 in - let r788 = R 282 :: r787 in - let r789 = S (T T_QUOTED_STRING_EXPR) :: r41 in - let r790 = [R 80] in - let r791 = Sub (r789) :: r790 in - let r792 = [R 90] in - let r793 = Sub (r791) :: r792 in - let r794 = [R 608] in - let r795 = R 274 :: r794 in - let r796 = R 288 :: r795 in - let r797 = Sub (r793) :: r796 in - let r798 = S (T T_COLON) :: r797 in - let r799 = S (T T_LIDENT) :: r798 in - let r800 = R 194 :: r799 in - let r801 = R 808 :: r800 in - let r802 = R 282 :: r801 in - let r803 = [R 94] in - let r804 = R 276 :: r803 in - let r805 = R 288 :: r804 in - let r806 = Sub (r791) :: r805 in - let r807 = S (T T_EQUAL) :: r806 in - let r808 = S (T T_LIDENT) :: r807 in - let r809 = R 194 :: r808 in - let r810 = R 808 :: r809 in - let r811 = R 282 :: r810 in - let r812 = [R 195] in - let r813 = S (T T_RBRACKET) :: r812 in - let r814 = [R 81] in - let r815 = S (T T_END) :: r814 in - let r816 = R 297 :: r815 in - let r817 = R 71 :: r816 in - let r818 = [R 70] in - let r819 = S (T T_RPAREN) :: r818 in - let r820 = [R 73] in - let r821 = R 288 :: r820 in - let r822 = Sub (r87) :: r821 in - let r823 = S (T T_COLON) :: r822 in - let r824 = S (T T_LIDENT) :: r823 in - let r825 = R 384 :: r824 in - let r826 = [R 74] in - let r827 = R 288 :: r826 in - let r828 = Sub (r89) :: r827 in - let r829 = S (T T_COLON) :: r828 in - let r830 = S (T T_LIDENT) :: r829 in - let r831 = R 519 :: r830 in - let r832 = [R 72] in - let r833 = R 288 :: r832 in - let r834 = Sub (r791) :: r833 in - let r835 = [R 83] in - let r836 = Sub (r791) :: r835 in - let r837 = S (T T_IN) :: r836 in - let r838 = Sub (r781) :: r837 in - let r839 = R 282 :: r838 in - let r840 = [R 84] in - let r841 = Sub (r791) :: r840 in - let r842 = S (T T_IN) :: r841 in - let r843 = Sub (r781) :: r842 in - let r844 = [R 559] in - let r845 = Sub (r87) :: r844 in - let r846 = [R 79] in - let r847 = Sub (r276) :: r846 in - let r848 = S (T T_RBRACKET) :: r847 in - let r849 = Sub (r845) :: r848 in - let r850 = [R 560] in - let r851 = [R 111] in - let r852 = Sub (r87) :: r851 in - let r853 = S (T T_EQUAL) :: r852 in - let r854 = Sub (r87) :: r853 in - let r855 = [R 75] in - let r856 = R 288 :: r855 in - let r857 = Sub (r854) :: r856 in - let r858 = [R 76] in - let r859 = [R 298] in - let r860 = [R 277] in - let r861 = R 276 :: r860 in - let r862 = R 288 :: r861 in - let r863 = Sub (r791) :: r862 in - let r864 = S (T T_EQUAL) :: r863 in - let r865 = S (T T_LIDENT) :: r864 in - let r866 = R 194 :: r865 in - let r867 = R 808 :: r866 in - let r868 = [R 92] in - let r869 = Sub (r793) :: r868 in - let r870 = S (T T_MINUSGREATER) :: r869 in - let r871 = Sub (r81) :: r870 in - let r872 = [R 93] in - let r873 = Sub (r793) :: r872 in - let r874 = [R 91] in - let r875 = Sub (r793) :: r874 in - let r876 = S (T T_MINUSGREATER) :: r875 in - let r877 = [R 275] in - let r878 = R 274 :: r877 in - let r879 = R 288 :: r878 in - let r880 = Sub (r793) :: r879 in - let r881 = S (T T_COLON) :: r880 in - let r882 = S (T T_LIDENT) :: r881 in - let r883 = R 194 :: r882 in - let r884 = R 808 :: r883 in - let r885 = [R 292] in - let r886 = [R 591] in - let r887 = [R 595] in - let r888 = [R 285] in - let r889 = R 284 :: r888 in - let r890 = R 288 :: r889 in - let r891 = R 540 :: r890 in - let r892 = R 777 :: r891 in - let r893 = S (T T_LIDENT) :: r892 in - let r894 = R 781 :: r893 in - let r895 = [R 596] in - let r896 = [R 287] in - let r897 = R 286 :: r896 in - let r898 = R 288 :: r897 in - let r899 = R 540 :: r898 in - let r900 = Sub (r177) :: r899 in - let r901 = S (T T_COLONEQUAL) :: r900 in - let r902 = S (T T_LIDENT) :: r901 in - let r903 = R 781 :: r902 in - let r904 = [R 52] in - let r905 = Sub (r789) :: r904 in - let r906 = [R 61] in - let r907 = Sub (r905) :: r906 in - let r908 = S (T T_EQUAL) :: r907 in - let r909 = [R 754] in - let r910 = R 272 :: r909 in - let r911 = R 288 :: r910 in - let r912 = Sub (r908) :: r911 in - let r913 = S (T T_LIDENT) :: r912 in - let r914 = R 194 :: r913 in - let r915 = R 808 :: r914 in - let r916 = R 282 :: r915 in - let r917 = [R 89] in - let r918 = S (T T_END) :: r917 in - let r919 = R 299 :: r918 in - let r920 = R 69 :: r919 in - let r921 = [R 803] in - let r922 = Sub (r1) :: r921 in + let r499 = S (T T_MINUSGREATER) :: r498 in + let r500 = R 485 :: r499 in + let r501 = Sub (r494) :: r500 in + let r502 = R 316 :: r501 in + let r503 = [R 546] in + let r504 = S (T T_UNDERSCORE) :: r503 in + let r505 = [R 280] in + let r506 = [R 279] in + let r507 = S (T T_RPAREN) :: r506 in + let r508 = R 496 :: r507 in + let r509 = [R 299] in + let r510 = [R 229] in + let r511 = S (T T_RPAREN) :: r510 in + let r512 = [R 283] in + let r513 = [R 486] in + let r514 = [R 134] in + let r515 = Sub (r174) :: r514 in + let r516 = R 316 :: r515 in + let r517 = [R 614] in + let r518 = [R 615] in + let r519 = Sub (r174) :: r518 in + let r520 = R 316 :: r519 in + let r521 = [R 595] in + let r522 = [R 123] in + let r523 = S (T T_DOWNTO) :: r522 in + let r524 = [R 151] in + let r525 = S (T T_DONE) :: r524 in + let r526 = Sub (r3) :: r525 in + let r527 = S (T T_DO) :: r526 in + let r528 = Sub (r3) :: r527 in + let r529 = Sub (r523) :: r528 in + let r530 = Sub (r3) :: r529 in + let r531 = S (T T_EQUAL) :: r530 in + let r532 = S (N N_pattern) :: r531 in + let r533 = R 316 :: r532 in + let r534 = [R 692] in + let r535 = [R 702] in + let r536 = S (T T_RPAREN) :: r535 in + let r537 = S (T T_LPAREN) :: r536 in + let r538 = S (T T_DOT) :: r537 in + let r539 = [R 712] in + let r540 = S (T T_RPAREN) :: r539 in + let r541 = S (N N_module_type) :: r540 in + let r542 = S (T T_COLON) :: r541 in + let r543 = S (N N_module_expr) :: r542 in + let r544 = R 316 :: r543 in + let r545 = [R 302] in + let r546 = Sub (r3) :: r545 in + let r547 = S (T T_EQUAL) :: r546 in + let r548 = [R 152] in + let r549 = Sub (r180) :: r548 in + let r550 = R 316 :: r549 in + let r551 = [R 699] in + let r552 = [R 675] in + let r553 = S (T T_RPAREN) :: r552 in + let r554 = Sub (r451) :: r553 in + let r555 = S (T T_LPAREN) :: r554 in + let r556 = [R 622] in + let r557 = Sub (r174) :: r556 in + let r558 = R 316 :: r557 in + let r559 = [R 198] in + let r560 = [R 199] in + let r561 = Sub (r174) :: r560 in + let r562 = R 316 :: r561 in + let r563 = [R 273] in + let r564 = [R 821] in + let r565 = Sub (r34) :: r564 in + let r566 = S (T T_COLON) :: r565 in + let r567 = [R 274] in + let r568 = S (T T_RPAREN) :: r567 in + let r569 = Sub (r566) :: r568 in + let r570 = [R 823] in + let r571 = [R 822] in + let r572 = [R 275] in + let r573 = [R 276] in + let r574 = [R 698] in + let r575 = [R 672] in + let r576 = S (T T_RPAREN) :: r575 in + let r577 = Sub (r3) :: r576 in + let r578 = S (T T_LPAREN) :: r577 in + let r579 = [R 610] in + let r580 = [R 611] in + let r581 = Sub (r174) :: r580 in + let r582 = R 316 :: r581 in + let r583 = [R 202] in + let r584 = Sub (r3) :: r583 in + let r585 = [R 178] in + let r586 = [R 179] in + let r587 = Sub (r174) :: r586 in + let r588 = R 316 :: r587 in + let r589 = [R 166] in + let r590 = [R 167] in + let r591 = Sub (r174) :: r590 in + let r592 = R 316 :: r591 in + let r593 = [R 200] in + let r594 = [R 201] in + let r595 = Sub (r174) :: r594 in + let r596 = R 316 :: r595 in + let r597 = [R 235] in + let r598 = Sub (r3) :: r597 in + let r599 = [R 172] in + let r600 = [R 173] in + let r601 = Sub (r174) :: r600 in + let r602 = R 316 :: r601 in + let r603 = [R 180] in + let r604 = [R 181] in + let r605 = Sub (r174) :: r604 in + let r606 = R 316 :: r605 in + let r607 = [R 164] in + let r608 = [R 165] in + let r609 = Sub (r174) :: r608 in + let r610 = R 316 :: r609 in + let r611 = [R 170] in + let r612 = [R 171] in + let r613 = Sub (r174) :: r612 in + let r614 = R 316 :: r613 in + let r615 = [R 168] in + let r616 = [R 169] in + let r617 = Sub (r174) :: r616 in + let r618 = R 316 :: r617 in + let r619 = [R 188] in + let r620 = [R 189] in + let r621 = Sub (r174) :: r620 in + let r622 = R 316 :: r621 in + let r623 = [R 176] in + let r624 = [R 177] in + let r625 = Sub (r174) :: r624 in + let r626 = R 316 :: r625 in + let r627 = [R 174] in + let r628 = [R 175] in + let r629 = Sub (r174) :: r628 in + let r630 = R 316 :: r629 in + let r631 = [R 184] in + let r632 = [R 185] in + let r633 = Sub (r174) :: r632 in + let r634 = R 316 :: r633 in + let r635 = [R 162] in + let r636 = [R 163] in + let r637 = Sub (r174) :: r636 in + let r638 = R 316 :: r637 in + let r639 = [R 160] in + let r640 = [R 161] in + let r641 = Sub (r174) :: r640 in + let r642 = R 316 :: r641 in + let r643 = [R 204] in + let r644 = [R 205] in + let r645 = Sub (r174) :: r644 in + let r646 = R 316 :: r645 in + let r647 = [R 158] in + let r648 = [R 159] in + let r649 = Sub (r174) :: r648 in + let r650 = R 316 :: r649 in + let r651 = [R 186] in + let r652 = [R 187] in + let r653 = Sub (r174) :: r652 in + let r654 = R 316 :: r653 in + let r655 = [R 182] in + let r656 = [R 183] in + let r657 = Sub (r174) :: r656 in + let r658 = R 316 :: r657 in + let r659 = [R 190] in + let r660 = [R 191] in + let r661 = Sub (r174) :: r660 in + let r662 = R 316 :: r661 in + let r663 = [R 192] in + let r664 = [R 193] in + let r665 = Sub (r174) :: r664 in + let r666 = R 316 :: r665 in + let r667 = [R 194] in + let r668 = [R 195] in + let r669 = Sub (r174) :: r668 in + let r670 = R 316 :: r669 in + let r671 = [R 612] in + let r672 = [R 613] in + let r673 = Sub (r174) :: r672 in + let r674 = R 316 :: r673 in + let r675 = [R 196] in + let r676 = [R 197] in + let r677 = Sub (r174) :: r676 in + let r678 = R 316 :: r677 in + let r679 = [R 19] in + let r680 = R 322 :: r679 in + let r681 = Sub (r388) :: r680 in + let r682 = [R 784] in + let r683 = Sub (r3) :: r682 in + let r684 = [R 290] in + let r685 = Sub (r3) :: r684 in + let r686 = S (T T_EQUAL) :: r685 in + let r687 = Sub (r34) :: r686 in + let r688 = S (T T_DOT) :: r687 in + let r689 = [R 289] in + let r690 = Sub (r3) :: r689 in + let r691 = S (T T_EQUAL) :: r690 in + let r692 = Sub (r34) :: r691 in + let r693 = [R 592] in + let r694 = [R 288] in + let r695 = Sub (r3) :: r694 in + let r696 = [R 785] in + let r697 = Sub (r496) :: r696 in + let r698 = S (T T_EQUAL) :: r697 in + let r699 = [R 292] in + let r700 = Sub (r3) :: r699 in + let r701 = S (T T_EQUAL) :: r700 in + let r702 = [R 291] in + let r703 = Sub (r3) :: r702 in + let r704 = [R 533] in + let r705 = [R 539] in + let r706 = [R 544] in + let r707 = [R 542] in + let r708 = [R 532] in + let r709 = [R 323] in + let r710 = [R 674] in + let r711 = S (T T_RBRACKET) :: r710 in + let r712 = Sub (r3) :: r711 in + let r713 = [R 673] in + let r714 = S (T T_RBRACE) :: r713 in + let r715 = Sub (r3) :: r714 in + let r716 = [R 676] in + let r717 = S (T T_RPAREN) :: r716 in + let r718 = Sub (r451) :: r717 in + let r719 = S (T T_LPAREN) :: r718 in + let r720 = [R 680] in + let r721 = S (T T_RBRACKET) :: r720 in + let r722 = Sub (r451) :: r721 in + let r723 = [R 678] in + let r724 = S (T T_RBRACE) :: r723 in + let r725 = Sub (r451) :: r724 in + let r726 = [R 272] in + let r727 = [R 216] in + let r728 = [R 217] in + let r729 = Sub (r174) :: r728 in + let r730 = R 316 :: r729 in + let r731 = [R 679] in + let r732 = S (T T_RBRACKET) :: r731 in + let r733 = Sub (r451) :: r732 in + let r734 = [R 224] in + let r735 = [R 225] in + let r736 = Sub (r174) :: r735 in + let r737 = R 316 :: r736 in + let r738 = [R 677] in + let r739 = S (T T_RBRACE) :: r738 in + let r740 = Sub (r451) :: r739 in + let r741 = [R 220] in + let r742 = [R 221] in + let r743 = Sub (r174) :: r742 in + let r744 = R 316 :: r743 in + let r745 = [R 210] in + let r746 = [R 211] in + let r747 = Sub (r174) :: r746 in + let r748 = R 316 :: r747 in + let r749 = [R 214] in + let r750 = [R 215] in + let r751 = Sub (r174) :: r750 in + let r752 = R 316 :: r751 in + let r753 = [R 212] in + let r754 = [R 213] in + let r755 = Sub (r174) :: r754 in + let r756 = R 316 :: r755 in + let r757 = [R 218] in + let r758 = [R 219] in + let r759 = Sub (r174) :: r758 in + let r760 = R 316 :: r759 in + let r761 = [R 226] in + let r762 = [R 227] in + let r763 = Sub (r174) :: r762 in + let r764 = R 316 :: r763 in + let r765 = [R 222] in + let r766 = [R 223] in + let r767 = Sub (r174) :: r766 in + let r768 = R 316 :: r767 in + let r769 = [R 208] in + let r770 = [R 209] in + let r771 = Sub (r174) :: r770 in + let r772 = R 316 :: r771 in + let r773 = [R 303] in + let r774 = Sub (r3) :: r773 in + let r775 = [R 305] in + let r776 = [R 696] in + let r777 = [R 708] in + let r778 = [R 707] in + let r779 = [R 711] in + let r780 = [R 710] in + let r781 = S (T T_LIDENT) :: r456 in + let r782 = [R 697] in + let r783 = S (T T_GREATERRBRACE) :: r782 in + let r784 = [R 704] in + let r785 = S (T T_RBRACE) :: r784 in + let r786 = [R 568] in + let r787 = Sub (r461) :: r786 in + let r788 = [R 149] in + let r789 = Sub (r174) :: r788 in + let r790 = R 316 :: r789 in + let r791 = [R 146] in + let r792 = [R 147] in + let r793 = Sub (r174) :: r792 in + let r794 = R 316 :: r793 in + let r795 = [R 144] in + let r796 = [R 145] in + let r797 = Sub (r174) :: r796 in + let r798 = R 316 :: r797 in + let r799 = [R 681] in + let r800 = [R 668] in + let r801 = S (T T_GREATERDOT) :: r800 in + let r802 = Sub (r174) :: r801 in + let r803 = R 316 :: r802 in + let r804 = [R 491] in + let r805 = Sub (r174) :: r804 in + let r806 = R 316 :: r805 in + let r807 = [R 693] in + let r808 = [R 384] in + let r809 = S (N N_module_expr) :: r808 in + let r810 = S (T T_EQUAL) :: r809 in + let r811 = [R 137] in + let r812 = Sub (r3) :: r811 in + let r813 = S (T T_IN) :: r812 in + let r814 = Sub (r810) :: r813 in + let r815 = Sub (r195) :: r814 in + let r816 = R 316 :: r815 in + let r817 = [R 385] in + let r818 = S (N N_module_expr) :: r817 in + let r819 = S (T T_EQUAL) :: r818 in + let r820 = [R 386] in + let r821 = [R 138] in + let r822 = Sub (r3) :: r821 in + let r823 = S (T T_IN) :: r822 in + let r824 = R 316 :: r823 in + let r825 = R 243 :: r824 in + let r826 = Sub (r90) :: r825 in + let r827 = R 316 :: r826 in + let r828 = [R 103] in + let r829 = Sub (r26) :: r828 in + let r830 = [R 244] in + let r831 = [R 263] in + let r832 = R 316 :: r831 in + let r833 = Sub (r141) :: r832 in + let r834 = S (T T_COLON) :: r833 in + let r835 = S (T T_LIDENT) :: r834 in + let r836 = R 414 :: r835 in + let r837 = [R 265] in + let r838 = Sub (r836) :: r837 in + let r839 = [R 105] in + let r840 = S (T T_RBRACE) :: r839 in + let r841 = [R 264] in + let r842 = R 316 :: r841 in + let r843 = S (T T_SEMI) :: r842 in + let r844 = R 316 :: r843 in + let r845 = Sub (r141) :: r844 in + let r846 = S (T T_COLON) :: r845 in + let r847 = [R 555] in + let r848 = Sub (r32) :: r847 in + let r849 = [R 104] in + let r850 = Sub (r26) :: r849 in + let r851 = [R 247] in + let r852 = [R 248] in + let r853 = Sub (r26) :: r852 in + let r854 = [R 246] in + let r855 = Sub (r26) :: r854 in + let r856 = [R 245] in + let r857 = Sub (r26) :: r856 in + let r858 = [R 207] in + let r859 = Sub (r174) :: r858 in + let r860 = R 316 :: r859 in + let r861 = [R 705] in + let r862 = [R 684] in + let r863 = S (T T_RPAREN) :: r862 in + let r864 = S (N N_module_expr) :: r863 in + let r865 = R 316 :: r864 in + let r866 = [R 685] in + let r867 = S (T T_RPAREN) :: r866 in + let r868 = [R 671] in + let r869 = [R 505] in + let r870 = S (T T_RPAREN) :: r869 in + let r871 = Sub (r174) :: r870 in + let r872 = R 316 :: r871 in + let r873 = [R 511] in + let r874 = S (T T_RPAREN) :: r873 in + let r875 = [R 507] in + let r876 = S (T T_RPAREN) :: r875 in + let r877 = [R 509] in + let r878 = S (T T_RPAREN) :: r877 in + let r879 = [R 510] in + let r880 = S (T T_RPAREN) :: r879 in + let r881 = [R 506] in + let r882 = S (T T_RPAREN) :: r881 in + let r883 = [R 508] in + let r884 = S (T T_RPAREN) :: r883 in + let r885 = [R 797] in + let r886 = R 322 :: r885 in + let r887 = Sub (r810) :: r886 in + let r888 = Sub (r195) :: r887 in + let r889 = R 316 :: r888 in + let r890 = [R 411] in + let r891 = R 322 :: r890 in + let r892 = R 492 :: r891 in + let r893 = Sub (r59) :: r892 in + let r894 = R 316 :: r893 in + let r895 = R 124 :: r894 in + let r896 = [R 493] in + let r897 = [R 798] in + let r898 = R 312 :: r897 in + let r899 = R 322 :: r898 in + let r900 = Sub (r810) :: r899 in + let r901 = [R 313] in + let r902 = R 312 :: r901 in + let r903 = R 322 :: r902 in + let r904 = Sub (r810) :: r903 in + let r905 = Sub (r195) :: r904 in + let r906 = [R 261] in + let r907 = S (T T_RBRACKET) :: r906 in + let r908 = Sub (r17) :: r907 in + let r909 = [R 550] in + let r910 = [R 551] in + let r911 = [R 131] in + let r912 = S (T T_RBRACKET) :: r911 in + let r913 = Sub (r19) :: r912 in + let r914 = [R 803] in + let r915 = R 322 :: r914 in + let r916 = S (N N_module_expr) :: r915 in + let r917 = R 316 :: r916 in + let r918 = [R 424] in + let r919 = S (T T_STRING) :: r918 in + let r920 = [R 557] in + let r921 = R 322 :: r920 in + let r922 = Sub (r919) :: r921 in let r923 = S (T T_EQUAL) :: r922 in - let r924 = S (T T_LIDENT) :: r923 in - let r925 = R 382 :: r924 in - let r926 = R 282 :: r925 in - let r927 = [R 55] in - let r928 = R 288 :: r927 in - let r929 = [R 804] in - let r930 = Sub (r1) :: r929 in - let r931 = S (T T_EQUAL) :: r930 in - let r932 = S (T T_LIDENT) :: r931 in - let r933 = R 382 :: r932 in - let r934 = [R 806] in - let r935 = Sub (r1) :: r934 in - let r936 = [R 802] in - let r937 = Sub (r87) :: r936 in - let r938 = S (T T_COLON) :: r937 in - let r939 = [R 805] in - let r940 = Sub (r1) :: r939 in - let r941 = [R 326] in - let r942 = Sub (r382) :: r941 in - let r943 = S (T T_LIDENT) :: r942 in - let r944 = R 517 :: r943 in - let r945 = R 282 :: r944 in - let r946 = [R 56] in - let r947 = R 288 :: r946 in - let r948 = [R 327] in - let r949 = Sub (r382) :: r948 in - let r950 = S (T T_LIDENT) :: r949 in - let r951 = R 517 :: r950 in - let r952 = [R 329] in - let r953 = Sub (r1) :: r952 in - let r954 = S (T T_EQUAL) :: r953 in - let r955 = [R 331] in - let r956 = Sub (r1) :: r955 in - let r957 = S (T T_EQUAL) :: r956 in - let r958 = Sub (r87) :: r957 in - let r959 = S (T T_DOT) :: r958 in - let r960 = [R 736] in - let r961 = [R 197] in - let r962 = Sub (r1) :: r961 in - let r963 = [R 325] in - let r964 = Sub (r89) :: r963 in - let r965 = S (T T_COLON) :: r964 in - let r966 = [R 328] in - let r967 = Sub (r1) :: r966 in - let r968 = S (T T_EQUAL) :: r967 in - let r969 = [R 330] in - let r970 = Sub (r1) :: r969 in - let r971 = S (T T_EQUAL) :: r970 in - let r972 = Sub (r87) :: r971 in - let r973 = S (T T_DOT) :: r972 in - let r974 = [R 58] in - let r975 = R 288 :: r974 in - let r976 = Sub (r1) :: r975 in - let r977 = [R 53] in - let r978 = R 288 :: r977 in - let r979 = R 449 :: r978 in - let r980 = Sub (r905) :: r979 in - let r981 = [R 54] in - let r982 = R 288 :: r981 in - let r983 = R 449 :: r982 in - let r984 = Sub (r905) :: r983 in - let r985 = [R 85] in - let r986 = S (T T_RPAREN) :: r985 in - let r987 = [R 48] in - let r988 = Sub (r905) :: r987 in - let r989 = S (T T_IN) :: r988 in - let r990 = Sub (r781) :: r989 in - let r991 = R 282 :: r990 in - let r992 = [R 262] in - let r993 = R 288 :: r992 in - let r994 = Sub (r236) :: r993 in - let r995 = R 524 :: r994 in - let r996 = R 282 :: r995 in - let r997 = [R 49] in - let r998 = Sub (r905) :: r997 in - let r999 = S (T T_IN) :: r998 in - let r1000 = Sub (r781) :: r999 in - let r1001 = [R 87] in - let r1002 = Sub (r212) :: r1001 in - let r1003 = S (T T_RBRACKET) :: r1002 in - let r1004 = [R 64] in - let r1005 = Sub (r905) :: r1004 in - let r1006 = S (T T_MINUSGREATER) :: r1005 in - let r1007 = Sub (r493) :: r1006 in - let r1008 = [R 46] in - let r1009 = Sub (r1007) :: r1008 in - let r1010 = [R 47] in - let r1011 = Sub (r905) :: r1010 in - let r1012 = [R 238] in - let r1013 = [R 261] in - let r1014 = R 288 :: r1013 in - let r1015 = Sub (r236) :: r1014 in - let r1016 = [R 88] in - let r1017 = S (T T_RPAREN) :: r1016 in - let r1018 = [R 450] in - let r1019 = [R 57] in - let r1020 = R 288 :: r1019 in - let r1021 = Sub (r854) :: r1020 in - let r1022 = [R 59] in - let r1023 = [R 300] in - let r1024 = [R 62] in - let r1025 = Sub (r905) :: r1024 in - let r1026 = S (T T_EQUAL) :: r1025 in - let r1027 = [R 63] in - let r1028 = [R 273] in - let r1029 = R 272 :: r1028 in - let r1030 = R 288 :: r1029 in - let r1031 = Sub (r908) :: r1030 in - let r1032 = S (T T_LIDENT) :: r1031 in - let r1033 = R 194 :: r1032 in - let r1034 = R 808 :: r1033 in - let r1035 = [R 296] in - let r1036 = [R 742] in - let r1037 = [R 746] in - let r1038 = [R 739] in - let r1039 = R 293 :: r1038 in - let r1040 = [R 625] in - let r1041 = S (T T_RBRACKET) :: r1040 in - let r1042 = Sub (r1) :: r1041 in - let r1043 = [R 624] in - let r1044 = S (T T_RBRACE) :: r1043 in - let r1045 = Sub (r1) :: r1044 in - let r1046 = [R 627] in - let r1047 = S (T T_RPAREN) :: r1046 in - let r1048 = Sub (r456) :: r1047 in - let r1049 = S (T T_LPAREN) :: r1048 in - let r1050 = [R 631] in + let r924 = Sub (r36) :: r923 in + let r925 = S (T T_COLON) :: r924 in + let r926 = Sub (r24) :: r925 in + let r927 = R 316 :: r926 in + let r928 = [R 553] in + let r929 = Sub (r34) :: r928 in + let r930 = Sub (r88) :: r357 in + let r931 = [R 783] in + let r932 = R 322 :: r931 in + let r933 = R 316 :: r932 in + let r934 = Sub (r930) :: r933 in + let r935 = S (T T_EQUAL) :: r934 in + let r936 = Sub (r90) :: r935 in + let r937 = R 316 :: r936 in + let r938 = [R 637] in + let r939 = R 322 :: r938 in + let r940 = R 316 :: r939 in + let r941 = R 243 :: r940 in + let r942 = Sub (r90) :: r941 in + let r943 = R 316 :: r942 in + let r944 = R 124 :: r943 in + let r945 = S (T T_COLONCOLON) :: r366 in + let r946 = [R 548] in + let r947 = [R 325] in + let r948 = [R 444] in + let r949 = R 322 :: r948 in + let r950 = Sub (r293) :: r949 in + let r951 = R 316 :: r950 in + let r952 = [R 445] in + let r953 = R 322 :: r952 in + let r954 = Sub (r293) :: r953 in + let r955 = R 316 :: r954 in + let r956 = [R 387] in + let r957 = S (N N_module_type) :: r956 in + let r958 = S (T T_COLON) :: r957 in + let r959 = [R 648] in + let r960 = R 322 :: r959 in + let r961 = Sub (r958) :: r960 in + let r962 = Sub (r195) :: r961 in + let r963 = R 316 :: r962 in + let r964 = [R 412] in + let r965 = R 322 :: r964 in + let r966 = S (N N_module_type) :: r965 in + let r967 = S (T T_COLONEQUAL) :: r966 in + let r968 = Sub (r59) :: r967 in + let r969 = R 316 :: r968 in + let r970 = [R 400] in + let r971 = R 322 :: r970 in + let r972 = [R 651] in + let r973 = R 314 :: r972 in + let r974 = R 322 :: r973 in + let r975 = S (N N_module_type) :: r974 in + let r976 = S (T T_COLON) :: r975 in + let r977 = [R 315] in + let r978 = R 314 :: r977 in + let r979 = R 322 :: r978 in + let r980 = S (N N_module_type) :: r979 in + let r981 = S (T T_COLON) :: r980 in + let r982 = Sub (r195) :: r981 in + let r983 = S (T T_UIDENT) :: r149 in + let r984 = Sub (r983) :: r233 in + let r985 = [R 649] in + let r986 = R 322 :: r985 in + let r987 = [R 388] in + let r988 = [R 655] in + let r989 = R 322 :: r988 in + let r990 = S (N N_module_type) :: r989 in + let r991 = R 316 :: r990 in + let r992 = S (T T_QUOTED_STRING_EXPR) :: r57 in + let r993 = [R 71] in + let r994 = Sub (r992) :: r993 in + let r995 = [R 81] in + let r996 = Sub (r994) :: r995 in + let r997 = [R 656] in + let r998 = R 308 :: r997 in + let r999 = R 322 :: r998 in + let r1000 = Sub (r996) :: r999 in + let r1001 = S (T T_COLON) :: r1000 in + let r1002 = S (T T_LIDENT) :: r1001 in + let r1003 = R 132 :: r1002 in + let r1004 = R 855 :: r1003 in + let r1005 = R 316 :: r1004 in + let r1006 = [R 85] in + let r1007 = R 310 :: r1006 in + let r1008 = R 322 :: r1007 in + let r1009 = Sub (r994) :: r1008 in + let r1010 = S (T T_EQUAL) :: r1009 in + let r1011 = S (T T_LIDENT) :: r1010 in + let r1012 = R 132 :: r1011 in + let r1013 = R 855 :: r1012 in + let r1014 = R 316 :: r1013 in + let r1015 = [R 133] in + let r1016 = S (T T_RBRACKET) :: r1015 in + let r1017 = [R 72] in + let r1018 = S (T T_END) :: r1017 in + let r1019 = R 331 :: r1018 in + let r1020 = R 62 :: r1019 in + let r1021 = [R 61] in + let r1022 = S (T T_RPAREN) :: r1021 in + let r1023 = [R 64] in + let r1024 = R 322 :: r1023 in + let r1025 = Sub (r34) :: r1024 in + let r1026 = S (T T_COLON) :: r1025 in + let r1027 = S (T T_LIDENT) :: r1026 in + let r1028 = R 416 :: r1027 in + let r1029 = [R 65] in + let r1030 = R 322 :: r1029 in + let r1031 = Sub (r36) :: r1030 in + let r1032 = S (T T_COLON) :: r1031 in + let r1033 = S (T T_LIDENT) :: r1032 in + let r1034 = R 560 :: r1033 in + let r1035 = [R 63] in + let r1036 = R 322 :: r1035 in + let r1037 = Sub (r994) :: r1036 in + let r1038 = [R 74] in + let r1039 = Sub (r994) :: r1038 in + let r1040 = S (T T_IN) :: r1039 in + let r1041 = Sub (r984) :: r1040 in + let r1042 = R 316 :: r1041 in + let r1043 = [R 75] in + let r1044 = Sub (r994) :: r1043 in + let r1045 = S (T T_IN) :: r1044 in + let r1046 = Sub (r984) :: r1045 in + let r1047 = [R 602] in + let r1048 = Sub (r34) :: r1047 in + let r1049 = [R 70] in + let r1050 = Sub (r286) :: r1049 in let r1051 = S (T T_RBRACKET) :: r1050 in - let r1052 = Sub (r456) :: r1051 in - let r1053 = [R 629] in - let r1054 = S (T T_RBRACE) :: r1053 in - let r1055 = Sub (r456) :: r1054 in - let r1056 = [R 180] in - let r1057 = [R 630] in - let r1058 = S (T T_RBRACKET) :: r1057 in - let r1059 = Sub (r456) :: r1058 in - let r1060 = [R 184] in - let r1061 = [R 628] in - let r1062 = S (T T_RBRACE) :: r1061 in - let r1063 = Sub (r456) :: r1062 in - let r1064 = [R 182] in - let r1065 = [R 177] in - let r1066 = [R 179] in - let r1067 = [R 178] in - let r1068 = [R 181] in - let r1069 = [R 185] in - let r1070 = [R 183] in - let r1071 = [R 176] in - let r1072 = [R 269] in - let r1073 = Sub (r1) :: r1072 in - let r1074 = [R 271] in - let r1075 = [R 647] in - let r1076 = [R 659] in - let r1077 = [R 658] in - let r1078 = [R 662] in - let r1079 = [R 661] in - let r1080 = S (T T_LIDENT) :: r461 in - let r1081 = [R 648] in - let r1082 = S (T T_GREATERRBRACE) :: r1081 in - let r1083 = [R 655] in - let r1084 = S (T T_RBRACE) :: r1083 in - let r1085 = [R 527] in - let r1086 = Sub (r466) :: r1085 in - let r1087 = [R 128] in - let r1088 = S (T T_DONE) :: r1087 in - let r1089 = Sub (r1) :: r1088 in - let r1090 = S (T T_DO) :: r1089 in - let r1091 = Sub (r1) :: r1090 in - let r1092 = Sub (r513) :: r1091 in - let r1093 = [R 201] in - let r1094 = Sub (r496) :: r1093 in - let r1095 = S (T T_RPAREN) :: r1094 in - let r1096 = [R 199] in - let r1097 = Sub (r1) :: r1096 in - let r1098 = S (T T_MINUSGREATER) :: r1097 in - let r1099 = [R 200] in - let r1100 = [R 552] in - let r1101 = [R 140] in - let r1102 = [R 632] in - let r1103 = [R 644] in - let r1104 = [R 131] in - let r1105 = Sub (r1) :: r1104 in - let r1106 = S (T T_IN) :: r1105 in - let r1107 = Sub (r613) :: r1106 in - let r1108 = Sub (r63) :: r1107 in - let r1109 = R 282 :: r1108 in - let r1110 = [R 132] in - let r1111 = Sub (r1) :: r1110 in - let r1112 = S (T T_IN) :: r1111 in - let r1113 = R 282 :: r1112 in - let r1114 = R 209 :: r1113 in - let r1115 = Sub (r130) :: r1114 in - let r1116 = R 282 :: r1115 in - let r1117 = [R 256] in - let r1118 = Sub (r1) :: r1117 in - let r1119 = S (T T_EQUAL) :: r1118 in - let r1120 = Sub (r87) :: r1119 in - let r1121 = S (T T_DOT) :: r1120 in - let r1122 = [R 255] in - let r1123 = Sub (r1) :: r1122 in - let r1124 = S (T T_EQUAL) :: r1123 in - let r1125 = Sub (r87) :: r1124 in - let r1126 = [R 254] in - let r1127 = Sub (r1) :: r1126 in - let r1128 = [R 656] in - let r1129 = [R 635] in - let r1130 = S (T T_RPAREN) :: r1129 in - let r1131 = S (N N_module_expr) :: r1130 in - let r1132 = R 282 :: r1131 in - let r1133 = [R 636] in - let r1134 = S (T T_RPAREN) :: r1133 in - let r1135 = [R 622] in - let r1136 = [R 470] in - let r1137 = S (T T_RPAREN) :: r1136 in - let r1138 = [R 468] in - let r1139 = S (T T_RPAREN) :: r1138 in - let r1140 = [R 469] in - let r1141 = S (T T_RPAREN) :: r1140 in - let r1142 = [R 295] in - let r1143 = R 293 :: r1142 in - let r1144 = [R 320] in - let r1145 = [R 29] in - let r1146 = [R 28] in - let r1147 = Sub (r126) :: r1146 in - let r1148 = [R 33] in - let r1149 = [R 565] in - let r1150 = [R 22] in - let r1151 = [R 566] in - let r1152 = [R 405] in - let r1153 = S (T T_RBRACE) :: r1152 in - let r1154 = [R 191] in - let r1155 = R 282 :: r1154 in - let r1156 = [R 192] in - let r1157 = R 282 :: r1156 in - let r1158 = [R 68] in - let r1159 = S (T T_RPAREN) :: r1158 in - let r1160 = [R 124] in - let r1161 = [R 126] in - let r1162 = [R 125] in - let r1163 = [R 223] in - let r1164 = [R 226] in - let r1165 = [R 337] in - let r1166 = [R 340] in - let r1167 = S (T T_RPAREN) :: r1166 in - let r1168 = S (T T_COLONCOLON) :: r1167 in - let r1169 = S (T T_LPAREN) :: r1168 in - let r1170 = [R 471] in - let r1171 = [R 472] in - let r1172 = [R 473] in - let r1173 = [R 474] in - let r1174 = [R 475] in - let r1175 = [R 476] in - let r1176 = [R 477] in - let r1177 = [R 478] in - let r1178 = [R 479] in - let r1179 = [R 480] in - let r1180 = [R 481] in - let r1181 = [R 761] in - let r1182 = [R 770] in - let r1183 = [R 302] in - let r1184 = [R 768] in - let r1185 = S (T T_SEMISEMI) :: r1184 in - let r1186 = [R 769] in - let r1187 = [R 304] in - let r1188 = [R 307] in - let r1189 = [R 306] in - let r1190 = [R 305] in - let r1191 = R 303 :: r1190 in - let r1192 = [R 797] in - let r1193 = S (T T_EOF) :: r1192 in - let r1194 = R 303 :: r1193 in - let r1195 = [R 796] in + let r1052 = Sub (r1048) :: r1051 in + let r1053 = [R 603] in + let r1054 = [R 102] in + let r1055 = Sub (r34) :: r1054 in + let r1056 = S (T T_EQUAL) :: r1055 in + let r1057 = Sub (r34) :: r1056 in + let r1058 = [R 66] in + let r1059 = R 322 :: r1058 in + let r1060 = Sub (r1057) :: r1059 in + let r1061 = [R 67] in + let r1062 = [R 332] in + let r1063 = [R 311] in + let r1064 = R 310 :: r1063 in + let r1065 = R 322 :: r1064 in + let r1066 = Sub (r994) :: r1065 in + let r1067 = S (T T_EQUAL) :: r1066 in + let r1068 = S (T T_LIDENT) :: r1067 in + let r1069 = R 132 :: r1068 in + let r1070 = R 855 :: r1069 in + let r1071 = [R 83] in + let r1072 = Sub (r996) :: r1071 in + let r1073 = S (T T_MINUSGREATER) :: r1072 in + let r1074 = Sub (r28) :: r1073 in + let r1075 = [R 84] in + let r1076 = Sub (r996) :: r1075 in + let r1077 = [R 82] in + let r1078 = Sub (r996) :: r1077 in + let r1079 = S (T T_MINUSGREATER) :: r1078 in + let r1080 = [R 309] in + let r1081 = R 308 :: r1080 in + let r1082 = R 322 :: r1081 in + let r1083 = Sub (r996) :: r1082 in + let r1084 = S (T T_COLON) :: r1083 in + let r1085 = S (T T_LIDENT) :: r1084 in + let r1086 = R 132 :: r1085 in + let r1087 = R 855 :: r1086 in + let r1088 = [R 326] in + let r1089 = [R 639] in + let r1090 = [R 643] in + let r1091 = [R 319] in + let r1092 = R 318 :: r1091 in + let r1093 = R 322 :: r1092 in + let r1094 = R 581 :: r1093 in + let r1095 = R 824 :: r1094 in + let r1096 = S (T T_LIDENT) :: r1095 in + let r1097 = R 828 :: r1096 in + let r1098 = [R 644] in + let r1099 = [R 321] in + let r1100 = R 320 :: r1099 in + let r1101 = R 322 :: r1100 in + let r1102 = R 581 :: r1101 in + let r1103 = Sub (r129) :: r1102 in + let r1104 = S (T T_COLONEQUAL) :: r1103 in + let r1105 = S (T T_LIDENT) :: r1104 in + let r1106 = R 828 :: r1105 in + let r1107 = [R 436] in + let r1108 = S (T T_RBRACE) :: r1107 in + let r1109 = [R 249] in + let r1110 = R 316 :: r1109 in + let r1111 = R 243 :: r1110 in + let r1112 = Sub (r90) :: r1111 in + let r1113 = [R 434] in + let r1114 = [R 435] in + let r1115 = [R 439] in + let r1116 = S (T T_RBRACE) :: r1115 in + let r1117 = [R 438] in + let r1118 = S (T T_RBRACE) :: r1117 in + let r1119 = [R 43] in + let r1120 = Sub (r992) :: r1119 in + let r1121 = [R 52] in + let r1122 = Sub (r1120) :: r1121 in + let r1123 = S (T T_EQUAL) :: r1122 in + let r1124 = [R 801] in + let r1125 = R 306 :: r1124 in + let r1126 = R 322 :: r1125 in + let r1127 = Sub (r1123) :: r1126 in + let r1128 = S (T T_LIDENT) :: r1127 in + let r1129 = R 132 :: r1128 in + let r1130 = R 855 :: r1129 in + let r1131 = R 316 :: r1130 in + let r1132 = [R 80] in + let r1133 = S (T T_END) :: r1132 in + let r1134 = R 333 :: r1133 in + let r1135 = R 60 :: r1134 in + let r1136 = [R 850] in + let r1137 = Sub (r3) :: r1136 in + let r1138 = S (T T_EQUAL) :: r1137 in + let r1139 = S (T T_LIDENT) :: r1138 in + let r1140 = R 414 :: r1139 in + let r1141 = R 316 :: r1140 in + let r1142 = [R 46] in + let r1143 = R 322 :: r1142 in + let r1144 = [R 851] in + let r1145 = Sub (r3) :: r1144 in + let r1146 = S (T T_EQUAL) :: r1145 in + let r1147 = S (T T_LIDENT) :: r1146 in + let r1148 = R 414 :: r1147 in + let r1149 = [R 853] in + let r1150 = Sub (r3) :: r1149 in + let r1151 = [R 849] in + let r1152 = Sub (r34) :: r1151 in + let r1153 = S (T T_COLON) :: r1152 in + let r1154 = [R 852] in + let r1155 = Sub (r3) :: r1154 in + let r1156 = S (T T_EQUAL) :: r683 in + let r1157 = [R 357] in + let r1158 = Sub (r1156) :: r1157 in + let r1159 = S (T T_LIDENT) :: r1158 in + let r1160 = R 558 :: r1159 in + let r1161 = R 316 :: r1160 in + let r1162 = [R 47] in + let r1163 = R 322 :: r1162 in + let r1164 = [R 358] in + let r1165 = Sub (r1156) :: r1164 in + let r1166 = S (T T_LIDENT) :: r1165 in + let r1167 = R 558 :: r1166 in + let r1168 = [R 360] in + let r1169 = Sub (r3) :: r1168 in + let r1170 = S (T T_EQUAL) :: r1169 in + let r1171 = [R 362] in + let r1172 = Sub (r3) :: r1171 in + let r1173 = S (T T_EQUAL) :: r1172 in + let r1174 = Sub (r34) :: r1173 in + let r1175 = S (T T_DOT) :: r1174 in + let r1176 = [R 356] in + let r1177 = Sub (r36) :: r1176 in + let r1178 = S (T T_COLON) :: r1177 in + let r1179 = [R 359] in + let r1180 = Sub (r3) :: r1179 in + let r1181 = S (T T_EQUAL) :: r1180 in + let r1182 = [R 361] in + let r1183 = Sub (r3) :: r1182 in + let r1184 = S (T T_EQUAL) :: r1183 in + let r1185 = Sub (r34) :: r1184 in + let r1186 = S (T T_DOT) :: r1185 in + let r1187 = [R 49] in + let r1188 = R 322 :: r1187 in + let r1189 = Sub (r3) :: r1188 in + let r1190 = [R 44] in + let r1191 = R 322 :: r1190 in + let r1192 = R 483 :: r1191 in + let r1193 = Sub (r1120) :: r1192 in + let r1194 = [R 45] in + let r1195 = R 322 :: r1194 in + let r1196 = R 483 :: r1195 in + let r1197 = Sub (r1120) :: r1196 in + let r1198 = [R 76] in + let r1199 = S (T T_RPAREN) :: r1198 in + let r1200 = [R 39] in + let r1201 = Sub (r1120) :: r1200 in + let r1202 = S (T T_IN) :: r1201 in + let r1203 = Sub (r984) :: r1202 in + let r1204 = R 316 :: r1203 in + let r1205 = [R 296] in + let r1206 = R 322 :: r1205 in + let r1207 = Sub (r388) :: r1206 in + let r1208 = R 565 :: r1207 in + let r1209 = R 316 :: r1208 in + let r1210 = [R 40] in + let r1211 = Sub (r1120) :: r1210 in + let r1212 = S (T T_IN) :: r1211 in + let r1213 = Sub (r984) :: r1212 in + let r1214 = [R 78] in + let r1215 = Sub (r226) :: r1214 in + let r1216 = S (T T_RBRACKET) :: r1215 in + let r1217 = [R 55] in + let r1218 = Sub (r1120) :: r1217 in + let r1219 = S (T T_MINUSGREATER) :: r1218 in + let r1220 = Sub (r488) :: r1219 in + let r1221 = [R 37] in + let r1222 = Sub (r1220) :: r1221 in + let r1223 = [R 38] in + let r1224 = Sub (r1120) :: r1223 in + let r1225 = [R 295] in + let r1226 = R 322 :: r1225 in + let r1227 = Sub (r388) :: r1226 in + let r1228 = [R 79] in + let r1229 = S (T T_RPAREN) :: r1228 in + let r1230 = [R 484] in + let r1231 = [R 48] in + let r1232 = R 322 :: r1231 in + let r1233 = Sub (r1057) :: r1232 in + let r1234 = [R 50] in + let r1235 = [R 334] in + let r1236 = [R 53] in + let r1237 = Sub (r1120) :: r1236 in + let r1238 = S (T T_EQUAL) :: r1237 in + let r1239 = [R 54] in + let r1240 = [R 307] in + let r1241 = R 306 :: r1240 in + let r1242 = R 322 :: r1241 in + let r1243 = Sub (r1123) :: r1242 in + let r1244 = S (T T_LIDENT) :: r1243 in + let r1245 = R 132 :: r1244 in + let r1246 = R 855 :: r1245 in + let r1247 = [R 330] in + let r1248 = [R 789] in + let r1249 = [R 793] in + let r1250 = [R 787] in + let r1251 = R 327 :: r1250 in + let r1252 = [R 329] in + let r1253 = R 327 :: r1252 in + let r1254 = [R 59] in + let r1255 = S (T T_RPAREN) :: r1254 in + let r1256 = [R 128] in + let r1257 = R 316 :: r1256 in + let r1258 = [R 129] in + let r1259 = R 316 :: r1258 in + let r1260 = [R 351] in + let r1261 = [R 440] in + let r1262 = [R 25] in + let r1263 = Sub (r86) :: r1262 in + let r1264 = [R 28] in + let r1265 = [R 608] in + let r1266 = [R 609] in + let r1267 = [R 437] in + let r1268 = S (T T_RBRACE) :: r1267 in + let r1269 = [R 252] in + let r1270 = R 322 :: r1269 in + let r1271 = R 581 :: r1270 in + let r1272 = [R 251] in + let r1273 = R 322 :: r1272 in + let r1274 = R 581 :: r1273 in + let r1275 = [R 257] in + let r1276 = [R 260] in + let r1277 = [R 368] in + let r1278 = [R 371] in + let r1279 = S (T T_RPAREN) :: r1278 in + let r1280 = S (T T_COLONCOLON) :: r1279 in + let r1281 = S (T T_LPAREN) :: r1280 in + let r1282 = [R 512] in + let r1283 = [R 513] in + let r1284 = [R 514] in + let r1285 = [R 515] in + let r1286 = [R 516] in + let r1287 = [R 517] in + let r1288 = [R 518] in + let r1289 = [R 519] in + let r1290 = [R 520] in + let r1291 = [R 521] in + let r1292 = [R 522] in + let r1293 = [R 808] in + let r1294 = [R 817] in + let r1295 = [R 336] in + let r1296 = [R 815] in + let r1297 = S (T T_SEMISEMI) :: r1296 in + let r1298 = [R 816] in + let r1299 = [R 338] in + let r1300 = [R 341] in + let r1301 = [R 340] in + let r1302 = [R 339] in + let r1303 = R 337 :: r1302 in + let r1304 = [R 844] in + let r1305 = S (T T_EOF) :: r1304 in + let r1306 = R 337 :: r1305 in + let r1307 = [R 843] in function - | 0 | 1760 | 1764 | 1782 | 1786 | 1790 | 1794 | 1798 | 1802 | 1806 | 1810 | 1814 | 1818 | 1824 | 1844 -> Nothing - | 1759 -> One ([R 0]) - | 1763 -> One ([R 1]) - | 1769 -> One ([R 2]) - | 1783 -> One ([R 3]) - | 1787 -> One ([R 4]) - | 1793 -> One ([R 5]) - | 1795 -> One ([R 6]) - | 1799 -> One ([R 7]) - | 1803 -> One ([R 8]) - | 1807 -> One ([R 9]) - | 1811 -> One ([R 10]) - | 1817 -> One ([R 11]) - | 1821 -> One ([R 12]) - | 1834 -> One ([R 13]) - | 1854 -> One ([R 14]) - | 214 -> One ([R 15]) - | 213 -> One ([R 16]) - | 1777 -> One ([R 20]) - | 1779 -> One ([R 21]) - | 284 -> One ([R 26]) - | 294 -> One ([R 27]) - | 290 -> One ([R 41]) - | 1268 -> One ([R 45]) - | 1277 -> One ([R 50]) - | 1272 -> One ([R 51]) - | 1313 -> One ([R 60]) - | 1280 -> One ([R 65]) - | 1064 -> One ([R 77]) - | 1044 -> One ([R 78]) - | 1046 -> One ([R 82]) - | 1275 -> One ([R 86]) - | 352 -> One ([R 97]) - | 73 -> One ([R 98]) - | 350 -> One ([R 99]) - | 72 -> One ([R 103]) - | 200 | 810 -> One ([R 104]) - | 842 -> One ([R 107]) - | 876 -> One ([R 115]) - | 880 -> One ([R 116]) - | 324 -> One ([R 118]) - | 1498 -> One ([R 119]) - | 622 -> One ([R 130]) - | 1446 -> One ([R 146]) - | 645 -> One ([R 147]) - | 667 -> One ([R 148]) - | 648 -> One ([R 149]) - | 665 -> One ([R 186]) - | 1 -> One (R 187 :: r7) - | 61 -> One (R 187 :: r24) - | 66 -> One (R 187 :: r29) - | 69 -> One (R 187 :: r40) - | 76 -> One (R 187 :: r48) - | 96 -> One (R 187 :: r67) - | 107 -> One (R 187 :: r95) - | 215 -> One (R 187 :: r199) - | 216 -> One (R 187 :: r203) - | 222 -> One (R 187 :: r215) - | 237 -> One (R 187 :: r225) - | 240 -> One (R 187 :: r230) - | 248 -> One (R 187 :: r241) - | 344 -> One (R 187 :: r319) - | 367 -> One (R 187 :: r332) - | 464 -> One (R 187 :: r406) - | 555 -> One (R 187 :: r476) - | 558 -> One (R 187 :: r479) - | 561 -> One (R 187 :: r484) - | 564 -> One (R 187 :: r487) - | 570 -> One (R 187 :: r500) - | 578 -> One (R 187 :: r511) - | 583 -> One (R 187 :: r523) - | 599 -> One (R 187 :: r534) - | 613 -> One (R 187 :: r540) - | 746 -> One (R 187 :: r618) - | 785 -> One (R 187 :: r649) - | 790 -> One (R 187 :: r659) - | 932 -> One (R 187 :: r748) - | 933 -> One (R 187 :: r752) - | 942 -> One (R 187 :: r760) - | 979 -> One (R 187 :: r788) - | 988 -> One (R 187 :: r802) - | 989 -> One (R 187 :: r811) - | 1152 -> One (R 187 :: r916) - | 1571 -> One (R 187 :: r1109) - | 1578 -> One (R 187 :: r1116) - | 1616 -> One (R 187 :: r1132) - | 476 -> One ([R 208]) - | 153 -> One ([R 221]) - | 131 -> One (R 224 :: r101) - | 135 -> One (R 224 :: r103) - | 212 -> One ([R 228]) - | 832 -> One ([R 232]) - | 833 -> One ([R 233]) - | 1271 -> One ([R 237]) - | 738 -> One ([R 251]) - | 1608 -> One ([R 253]) - | 1351 -> One ([R 260]) - | 1278 -> One ([R 263]) - | 447 -> One ([R 264]) - | 1588 -> One ([R 266]) - | 105 -> One (R 282 :: r75) - | 171 -> One (R 282 :: r122) - | 220 -> One (R 282 :: r208) - | 233 -> One (R 282 :: r220) - | 467 -> One (R 282 :: r410) - | 474 -> One (R 282 :: r420) - | 715 -> One (R 282 :: r595) - | 769 -> One (R 282 :: r638) - | 961 -> One (R 282 :: r779) - | 1000 -> One (R 282 :: r817) - | 1006 -> One (R 282 :: r825) - | 1017 -> One (R 282 :: r831) - | 1028 -> One (R 282 :: r834) - | 1032 -> One (R 282 :: r843) - | 1053 -> One (R 282 :: r857) - | 1069 -> One (R 282 :: r867) - | 1104 -> One (R 282 :: r884) - | 1126 -> One (R 282 :: r894) - | 1136 -> One (R 282 :: r903) - | 1159 -> One (R 282 :: r920) - | 1163 -> One (R 282 :: r933) - | 1191 -> One (R 282 :: r951) - | 1237 -> One (R 282 :: r976) - | 1241 -> One (R 282 :: r980) - | 1242 -> One (R 282 :: r984) - | 1253 -> One (R 282 :: r1000) - | 1261 -> One (R 282 :: r1009) - | 1305 -> One (R 282 :: r1021) - | 1325 -> One (R 282 :: r1034) - | 1659 -> One (R 282 :: r1144) - | 1125 -> One (R 284 :: r887) - | 1354 -> One (R 284 :: r1037) - | 1135 -> One (R 286 :: r895) - | 754 -> One (R 288 :: r626) - | 1062 -> One (R 288 :: r858) - | 1123 -> One (R 288 :: r886) - | 1311 -> One (R 288 :: r1022) - | 1352 -> One (R 288 :: r1036) - | 1359 -> One (R 288 :: r1039) - | 1651 -> One (R 288 :: r1143) - | 1839 -> One (R 288 :: r1185) - | 1850 -> One (R 288 :: r1191) - | 1855 -> One (R 288 :: r1194) - | 931 -> One (R 290 :: r744) - | 1115 -> One (R 290 :: r885) - | 211 -> One (R 293 :: r195) - | 1335 -> One (R 293 :: r1035) - | 1065 -> One (R 297 :: r859) - | 1314 -> One (R 299 :: r1023) - | 1837 -> One (R 301 :: r1183) - | 1845 -> One (R 303 :: r1187) - | 1846 -> One (R 303 :: r1188) - | 1847 -> One (R 303 :: r1189) - | 421 -> One ([R 309]) - | 425 -> One ([R 311]) - | 656 -> One ([R 313]) - | 1348 -> One ([R 314]) - | 1535 -> One ([R 317]) - | 1662 -> One ([R 318]) - | 1665 -> One ([R 319]) - | 1664 -> One ([R 321]) - | 1663 -> One ([R 323]) - | 1661 -> One ([R 324]) - | 1778 -> One ([R 336]) - | 1768 -> One ([R 338]) - | 1776 -> One ([R 339]) - | 1775 -> One ([R 341]) - | 590 -> One ([R 348]) - | 1496 -> One ([R 349]) - | 532 -> One ([R 360]) - | 542 -> One ([R 361]) - | 543 -> One ([R 362]) - | 541 -> One ([R 363]) - | 544 -> One ([R 365]) - | 170 -> One ([R 366]) - | 100 | 952 -> One ([R 367]) - | 503 -> One ([R 374]) - | 480 -> One ([R 375]) - | 510 -> One ([R 378]) - | 818 | 1177 -> One ([R 383]) - | 1010 -> One ([R 385]) - | 1008 -> One ([R 386]) - | 1011 -> One ([R 387]) - | 1009 -> One ([R 388]) - | 385 -> One ([R 391]) - | 803 -> One ([R 393]) - | 888 -> One ([R 394]) - | 1687 -> One ([R 395]) - | 904 -> One ([R 396]) - | 1688 -> One ([R 397]) - | 903 -> One ([R 398]) - | 895 -> One ([R 399]) - | 90 | 244 -> One ([R 412]) - | 114 | 608 -> One ([R 413]) - | 142 -> One ([R 414]) - | 130 -> One ([R 416]) - | 134 -> One ([R 418]) - | 138 -> One ([R 420]) - | 121 -> One ([R 421]) - | 141 | 1466 -> One ([R 422]) - | 120 -> One ([R 423]) - | 119 -> One ([R 424]) - | 118 -> One ([R 425]) - | 117 -> One ([R 426]) - | 116 -> One ([R 427]) - | 93 | 111 | 598 -> One ([R 428]) - | 92 | 597 -> One ([R 429]) - | 91 -> One ([R 430]) - | 113 | 391 | 607 -> One ([R 431]) - | 112 | 606 -> One ([R 432]) - | 88 -> One ([R 433]) - | 94 -> One ([R 434]) - | 123 -> One ([R 435]) - | 115 -> One ([R 436]) - | 122 -> One ([R 437]) - | 95 -> One ([R 438]) - | 140 -> One ([R 439]) - | 143 -> One ([R 440]) - | 139 -> One ([R 442]) - | 311 -> One ([R 443]) - | 310 -> One (R 444 :: r302) - | 262 -> One (R 445 :: r263) - | 263 -> One ([R 446]) - | 422 -> One (R 447 :: r353) - | 423 -> One ([R 448]) - | 1485 -> One ([R 462]) - | 159 -> One ([R 463]) - | 377 -> One ([R 483]) - | 371 -> One ([R 484]) - | 372 -> One ([R 486]) - | 370 | 609 -> One ([R 493]) - | 733 -> One ([R 499]) - | 734 -> One ([R 500]) - | 735 -> One ([R 502]) - | 453 -> One ([R 504]) - | 1151 -> One ([R 508]) - | 910 | 1218 -> One ([R 518]) - | 1021 -> One ([R 520]) - | 1019 -> One ([R 521]) - | 1022 -> One ([R 522]) - | 1020 -> One ([R 523]) - | 1287 -> One (R 524 :: r1015) - | 251 -> One ([R 525]) - | 886 -> One ([R 528]) - | 887 -> One ([R 529]) - | 882 -> One ([R 530]) - | 1704 -> One ([R 532]) - | 1703 -> One ([R 533]) - | 1705 -> One ([R 534]) - | 1700 -> One ([R 535]) - | 1701 -> One ([R 536]) - | 916 -> One ([R 538]) - | 914 -> One ([R 539]) - | 525 -> One ([R 542]) - | 477 -> One ([R 543]) - | 1274 -> One ([R 544]) - | 1273 -> One ([R 545]) - | 339 -> One ([R 547]) - | 303 -> One ([R 571]) - | 1385 -> One ([R 574]) - | 1386 -> One ([R 575]) - | 1558 -> One ([R 577]) - | 1559 -> One ([R 578]) - | 416 -> One ([R 580]) - | 417 -> One ([R 581]) - | 1488 -> One ([R 583]) - | 1489 -> One ([R 584]) - | 670 -> One ([R 586]) - | 674 -> One ([R 587]) - | 1146 -> One ([R 592]) - | 1114 -> One ([R 593]) - | 1117 -> One ([R 594]) - | 1116 -> One ([R 599]) - | 1121 -> One ([R 602]) - | 1120 -> One ([R 604]) - | 1119 -> One ([R 605]) - | 1118 -> One ([R 606]) - | 1147 -> One ([R 609]) - | 86 -> One ([R 612]) - | 83 -> One ([R 614]) - | 589 -> One ([R 638]) - | 652 -> One ([R 639]) - | 651 | 666 -> One ([R 640]) - | 592 | 647 -> One ([R 641]) - | 1393 | 1443 -> One ([R 646]) - | 650 -> One ([R 651]) - | 353 -> One ([R 664]) - | 357 -> One ([R 667]) - | 358 -> One ([R 671]) - | 389 -> One ([R 673]) - | 362 -> One ([R 674]) - | 418 -> One ([R 676]) - | 380 -> One ([R 681]) - | 28 -> One ([R 682]) - | 8 -> One ([R 683]) - | 52 -> One ([R 685]) - | 51 -> One ([R 686]) - | 50 -> One ([R 687]) - | 49 -> One ([R 688]) - | 48 -> One ([R 689]) - | 47 -> One ([R 690]) - | 46 -> One ([R 691]) - | 45 -> One ([R 692]) - | 44 -> One ([R 693]) - | 43 -> One ([R 694]) - | 42 -> One ([R 695]) - | 41 -> One ([R 696]) - | 40 -> One ([R 697]) - | 39 -> One ([R 698]) - | 38 -> One ([R 699]) - | 37 -> One ([R 700]) - | 36 -> One ([R 701]) - | 35 -> One ([R 702]) - | 34 -> One ([R 703]) - | 33 -> One ([R 704]) - | 32 -> One ([R 705]) - | 31 -> One ([R 706]) - | 30 -> One ([R 707]) - | 29 -> One ([R 708]) - | 27 -> One ([R 709]) - | 26 -> One ([R 710]) - | 25 -> One ([R 711]) - | 24 -> One ([R 712]) - | 23 -> One ([R 713]) - | 22 -> One ([R 714]) - | 21 -> One ([R 715]) - | 20 -> One ([R 716]) - | 19 -> One ([R 717]) - | 18 -> One ([R 718]) - | 17 -> One ([R 719]) - | 16 -> One ([R 720]) - | 15 -> One ([R 721]) - | 14 -> One ([R 722]) - | 13 -> One ([R 723]) - | 12 -> One ([R 724]) - | 11 -> One ([R 725]) - | 10 -> One ([R 726]) - | 9 -> One ([R 727]) - | 7 -> One ([R 728]) - | 6 -> One ([R 729]) - | 5 -> One ([R 730]) - | 4 -> One ([R 731]) - | 3 -> One ([R 732]) - | 1343 -> One ([R 733]) - | 1365 -> One ([R 738]) - | 1347 | 1364 -> One ([R 740]) - | 1350 | 1366 -> One ([R 741]) - | 1356 -> One ([R 743]) - | 1344 -> One ([R 744]) - | 1334 -> One ([R 745]) - | 1342 -> One ([R 749]) - | 1346 -> One ([R 752]) - | 1345 -> One ([R 753]) - | 1357 -> One ([R 755]) - | 236 -> One ([R 757]) - | 235 -> One ([R 758]) - | 1828 -> One ([R 762]) - | 1829 -> One ([R 763]) - | 1831 -> One ([R 764]) - | 1832 -> One ([R 765]) - | 1830 -> One ([R 766]) - | 1827 -> One ([R 767]) - | 1833 -> One ([R 771]) - | 287 -> One ([R 773]) - | 483 -> One (R 781 :: r437) - | 497 -> One ([R 782]) - | 177 -> One ([R 787]) - | 180 -> One ([R 788]) - | 184 -> One ([R 789]) - | 178 -> One ([R 790]) - | 185 -> One ([R 791]) - | 181 -> One ([R 792]) - | 186 -> One ([R 793]) - | 183 -> One ([R 794]) - | 176 -> One ([R 795]) - | 354 -> One ([R 800]) - | 649 -> One ([R 801]) - | 992 -> One ([R 809]) - | 1175 -> One ([R 810]) - | 1178 -> One ([R 811]) - | 1176 -> One ([R 812]) - | 1216 -> One ([R 813]) - | 1219 -> One ([R 814]) - | 1217 -> One ([R 815]) - | 486 -> One ([R 822]) - | 487 -> One ([R 823]) - | 1481 -> One (S (T T_WITH) :: r1086) - | 166 -> One (S (T T_TYPE) :: r119) - | 455 -> One (S (T T_TYPE) :: r388) - | 835 -> One (S (T T_STAR) :: r700) - | 1835 -> One (S (T T_SEMISEMI) :: r1182) - | 1842 -> One (S (T T_SEMISEMI) :: r1186) - | 1765 -> One (S (T T_RPAREN) :: r54) - | 365 -> One (S (T T_RPAREN) :: r329) - | 409 -> One (S (T T_RPAREN) :: r352) - | 469 -> One (S (T T_RPAREN) :: r411) - | 534 -> One (S (T T_RPAREN) :: r452) - | 1467 -> One (S (T T_RPAREN) :: r1075) - | 1626 -> One (S (T T_RPAREN) :: r1135) - | 1672 -> One (S (T T_RPAREN) :: r1147) - | 1679 -> One (S (T T_RPAREN) :: r1150) - | 1766 -> One (S (T T_RPAREN) :: r1165) - | 814 | 871 -> One (S (T T_RBRACKET) :: r243) - | 265 -> One (S (T T_RBRACKET) :: r264) - | 1473 -> One (S (T T_RBRACKET) :: r1078) - | 1475 -> One (S (T T_RBRACKET) :: r1079) - | 317 -> One (S (T T_QUOTE) :: r305) - | 1030 -> One (S (T T_OPEN) :: r839) - | 1245 -> One (S (T T_OPEN) :: r991) - | 160 -> One (S (T T_MODULE) :: r115) - | 851 -> One (S (T T_MINUSGREATER) :: r706) - | 855 -> One (S (T T_MINUSGREATER) :: r708) - | 1091 -> One (S (T T_MINUSGREATER) :: r873) - | 124 -> One (S (T T_LPAREN) :: r98) - | 156 -> One (S (T T_LIDENT) :: r110) - | 430 -> One (S (T T_LIDENT) :: r355) - | 438 -> One (S (T T_LIDENT) :: r361) - | 623 -> One (S (T T_LIDENT) :: r547) - | 624 -> One (S (T T_LIDENT) :: r553) - | 635 -> One (S (T T_LIDENT) :: r556) - | 639 -> One (S (T T_LIDENT) :: r558) - | 819 -> One (S (T T_LIDENT) :: r696) - | 1179 -> One (S (T T_LIDENT) :: r938) - | 1220 -> One (S (T T_LIDENT) :: r965) - | 1297 -> One (S (T T_LIDENT) :: r1018) - | 81 -> One (S (T T_INT) :: r52) - | 84 -> One (S (T T_INT) :: r53) - | 653 -> One (S (T T_IN) :: r565) - | 657 -> One (S (T T_IN) :: r567) - | 1265 -> One (S (T T_IN) :: r1011) - | 548 -> One (S (T T_GREATERRBRACE) :: r459) - | 1561 -> One (S (T T_GREATERRBRACE) :: r1103) - | 206 -> One (S (T T_GREATER) :: r186) - | 1667 -> One (S (T T_GREATER) :: r1145) - | 515 -> One (S (T T_EQUAL) :: r448) - | 722 -> One (S (T T_EQUAL) :: r600) - | 1169 -> One (S (T T_EQUAL) :: r935) - | 1187 -> One (S (T T_EQUAL) :: r940) - | 1208 -> One (S (T T_EQUAL) :: r962) - | 1457 -> One (S (T T_EQUAL) :: r1073) - | 1605 -> One (S (T T_EQUAL) :: r1127) - | 1757 -> One (S (T T_EOF) :: r1163) - | 1761 -> One (S (T T_EOF) :: r1164) - | 1780 -> One (S (T T_EOF) :: r1170) - | 1784 -> One (S (T T_EOF) :: r1171) - | 1788 -> One (S (T T_EOF) :: r1172) - | 1791 -> One (S (T T_EOF) :: r1173) - | 1796 -> One (S (T T_EOF) :: r1174) - | 1800 -> One (S (T T_EOF) :: r1175) - | 1804 -> One (S (T T_EOF) :: r1176) - | 1808 -> One (S (T T_EOF) :: r1177) - | 1812 -> One (S (T T_EOF) :: r1178) - | 1815 -> One (S (T T_EOF) :: r1179) - | 1819 -> One (S (T T_EOF) :: r1180) - | 1859 -> One (S (T T_EOF) :: r1195) - | 1548 -> One (S (T T_END) :: r1102) - | 126 -> One (S (T T_DOTDOT) :: r99) - | 201 -> One (S (T T_DOTDOT) :: r179) - | 889 -> One (S (T T_DOTDOT) :: r735) - | 890 -> One (S (T T_DOTDOT) :: r736) - | 226 | 1379 | 1426 -> One (S (T T_DOT) :: r217) - | 1822 -> One (S (T T_DOT) :: r449) - | 795 -> One (S (T T_DOT) :: r661) - | 822 -> One (S (T T_DOT) :: r698) - | 849 -> One (S (T T_DOT) :: r704) - | 1600 -> One (S (T T_DOT) :: r1125) - | 1770 -> One (S (T T_DOT) :: r1169) - | 202 | 811 -> One (S (T T_COLONCOLON) :: r181) - | 207 -> One (S (T T_COLON) :: r191) - | 471 -> One (S (T T_COLON) :: r414) - | 1085 -> One (S (T T_COLON) :: r871) - | 245 -> One (S (T T_BARRBRACKET) :: r233) - | 253 -> One (S (T T_BARRBRACKET) :: r242) - | 427 -> One (S (T T_BARRBRACKET) :: r354) - | 1469 -> One (S (T T_BARRBRACKET) :: r1076) - | 1471 -> One (S (T T_BARRBRACKET) :: r1077) - | 1613 -> One (S (T T_BARRBRACKET) :: r1128) - | 328 -> One (S (T T_BAR) :: r308) - | 79 -> One (S (N N_pattern) :: r50) - | 382 | 573 | 1517 -> One (S (N N_pattern) :: r56) - | 343 -> One (S (N N_pattern) :: r313) - | 373 -> One (S (N N_pattern) :: r333) - | 375 -> One (S (N N_pattern) :: r334) - | 396 -> One (S (N N_pattern) :: r345) - | 401 -> One (S (N N_pattern) :: r348) - | 725 -> One (S (N N_pattern) :: r601) - | 727 -> One (S (N N_pattern) :: r602) - | 729 -> One (S (N N_pattern) :: r603) - | 736 -> One (S (N N_pattern) :: r605) - | 742 -> One (S (N N_pattern) :: r609) - | 103 -> One (S (N N_module_type) :: r69) - | 473 -> One (S (N N_module_type) :: r416) - | 511 -> One (S (N N_module_type) :: r445) - | 513 -> One (S (N N_module_type) :: r446) - | 538 -> One (S (N N_module_type) :: r454) - | 751 -> One (S (N N_module_type) :: r625) - | 763 -> One (S (N N_module_type) :: r633) - | 1621 -> One (S (N N_module_type) :: r1134) - | 1636 -> One (S (N N_module_type) :: r1137) - | 1639 -> One (S (N N_module_type) :: r1139) - | 1642 -> One (S (N N_module_type) :: r1141) - | 219 -> One (S (N N_module_expr) :: r205) - | 446 -> One (S (N N_let_pattern) :: r378) - | 247 -> One (S (N N_expr) :: r234) - | 550 -> One (S (N N_expr) :: r462) - | 554 -> One (S (N N_expr) :: r473) - | 621 -> One (S (N N_expr) :: r546) - | 646 -> One (S (N N_expr) :: r563) - | 661 -> One (S (N N_expr) :: r568) - | 663 -> One (S (N N_expr) :: r569) - | 668 -> One (S (N N_expr) :: r570) - | 675 -> One (S (N N_expr) :: r573) - | 677 -> One (S (N N_expr) :: r574) - | 679 -> One (S (N N_expr) :: r575) - | 681 -> One (S (N N_expr) :: r576) - | 683 -> One (S (N N_expr) :: r577) - | 685 -> One (S (N N_expr) :: r578) - | 687 -> One (S (N N_expr) :: r579) - | 689 -> One (S (N N_expr) :: r580) - | 691 -> One (S (N N_expr) :: r581) - | 693 -> One (S (N N_expr) :: r582) - | 695 -> One (S (N N_expr) :: r583) - | 697 -> One (S (N N_expr) :: r584) - | 699 -> One (S (N N_expr) :: r585) - | 701 -> One (S (N N_expr) :: r586) - | 703 -> One (S (N N_expr) :: r587) - | 705 -> One (S (N N_expr) :: r588) - | 707 -> One (S (N N_expr) :: r589) - | 709 -> One (S (N N_expr) :: r590) - | 711 -> One (S (N N_expr) :: r591) - | 713 -> One (S (N N_expr) :: r592) - | 1398 -> One (S (N N_expr) :: r1056) - | 1403 -> One (S (N N_expr) :: r1060) - | 1408 -> One (S (N N_expr) :: r1064) - | 1414 -> One (S (N N_expr) :: r1065) - | 1419 -> One (S (N N_expr) :: r1066) - | 1424 -> One (S (N N_expr) :: r1067) - | 1431 -> One (S (N N_expr) :: r1068) - | 1436 -> One (S (N N_expr) :: r1069) - | 1441 -> One (S (N N_expr) :: r1070) - | 1444 -> One (S (N N_expr) :: r1071) - | 1545 -> One (S (N N_expr) :: r1101) - | 441 -> One (Sub (r1) :: r365) - | 569 -> One (Sub (r1) :: r491) - | 744 -> One (Sub (r1) :: r610) - | 1509 -> One (Sub (r1) :: r1092) - | 1742 -> One (Sub (r1) :: r1161) - | 1744 -> One (Sub (r1) :: r1162) - | 2 -> One (Sub (r11) :: r12) - | 55 -> One (Sub (r11) :: r13) - | 59 -> One (Sub (r11) :: r18) - | 209 -> One (Sub (r11) :: r194) - | 671 -> One (Sub (r11) :: r572) - | 740 -> One (Sub (r11) :: r608) - | 781 -> One (Sub (r11) :: r642) - | 783 -> One (Sub (r11) :: r645) - | 1246 -> One (Sub (r11) :: r996) - | 567 -> One (Sub (r33) :: r488) - | 1539 -> One (Sub (r33) :: r1100) - | 1740 -> One (Sub (r35) :: r1160) - | 75 -> One (Sub (r42) :: r43) - | 553 -> One (Sub (r42) :: r471) - | 588 -> One (Sub (r42) :: r524) - | 617 -> One (Sub (r42) :: r541) - | 637 -> One (Sub (r42) :: r557) - | 1269 -> One (Sub (r42) :: r1012) - | 759 -> One (Sub (r63) :: r630) - | 956 -> One (Sub (r63) :: r773) - | 863 -> One (Sub (r72) :: r709) - | 403 -> One (Sub (r77) :: r349) - | 731 -> One (Sub (r77) :: r604) - | 288 -> One (Sub (r79) :: r291) - | 300 -> One (Sub (r79) :: r296) - | 848 -> One (Sub (r79) :: r702) - | 1521 -> One (Sub (r79) :: r1098) - | 295 -> One (Sub (r81) :: r295) - | 1093 -> One (Sub (r81) :: r876) - | 286 -> One (Sub (r83) :: r290) - | 314 -> One (Sub (r85) :: r303) - | 490 -> One (Sub (r85) :: r439) - | 261 -> One (Sub (r87) :: r256) - | 398 -> One (Sub (r87) :: r347) - | 433 -> One (Sub (r87) :: r360) - | 448 -> One (Sub (r87) :: r379) - | 493 -> One (Sub (r87) :: r442) - | 610 -> One (Sub (r87) :: r537) - | 626 -> One (Sub (r87) :: r554) - | 630 -> One (Sub (r87) :: r555) - | 718 -> One (Sub (r87) :: r598) - | 1002 -> One (Sub (r87) :: r819) - | 1040 -> One (Sub (r87) :: r850) - | 1677 -> One (Sub (r87) :: r1149) - | 1681 -> One (Sub (r87) :: r1151) - | 1730 -> One (Sub (r87) :: r1159) - | 1195 -> One (Sub (r89) :: r954) - | 1226 -> One (Sub (r89) :: r968) - | 189 -> One (Sub (r105) :: r174) - | 796 -> One (Sub (r105) :: r662) - | 1825 -> One (Sub (r105) :: r1181) - | 348 -> One (Sub (r126) :: r321) - | 195 -> One (Sub (r169) :: r175) - | 182 -> One (Sub (r171) :: r173) - | 994 -> One (Sub (r171) :: r813) - | 199 -> One (Sub (r177) :: r178) - | 870 -> One (Sub (r177) :: r728) - | 919 -> One (Sub (r177) :: r743) - | 256 -> One (Sub (r253) :: r255) - | 307 -> One (Sub (r258) :: r297) - | 267 -> One (Sub (r260) :: r266) - | 281 -> One (Sub (r260) :: r289) - | 268 -> One (Sub (r272) :: r274) - | 269 -> One (Sub (r276) :: r277) - | 292 -> One (Sub (r276) :: r292) - | 1674 -> One (Sub (r276) :: r1148) - | 271 -> One (Sub (r285) :: r287) - | 519 -> One (Sub (r285) :: r450) - | 953 -> One (Sub (r285) :: r768) - | 336 -> One (Sub (r310) :: r312) - | 459 -> One (Sub (r316) :: r389) - | 359 -> One (Sub (r324) :: r325) - | 383 -> One (Sub (r338) :: r341) - | 574 -> One (Sub (r338) :: r503) - | 1196 -> One (Sub (r338) :: r959) - | 1227 -> One (Sub (r338) :: r973) - | 1518 -> One (Sub (r338) :: r1095) - | 1594 -> One (Sub (r338) :: r1121) - | 431 -> One (Sub (r357) :: r359) - | 439 -> One (Sub (r357) :: r364) - | 1463 -> One (Sub (r367) :: r1074) - | 442 -> One (Sub (r369) :: r372) - | 444 -> One (Sub (r374) :: r375) - | 1207 -> One (Sub (r384) :: r960) - | 523 -> One (Sub (r430) :: r451) - | 482 -> One (Sub (r432) :: r433) - | 551 -> One (Sub (r468) :: r470) - | 1480 -> One (Sub (r468) :: r1084) - | 1525 -> One (Sub (r496) :: r1099) - | 775 -> One (Sub (r613) :: r639) - | 1695 -> One (Sub (r663) :: r1155) - | 1707 -> One (Sub (r663) :: r1157) - | 816 -> One (Sub (r679) :: r680) - | 817 -> One (Sub (r688) :: r690) - | 872 -> One (Sub (r688) :: r730) - | 891 -> One (Sub (r688) :: r738) - | 899 -> One (Sub (r688) :: r740) - | 1683 -> One (Sub (r688) :: r1153) - | 977 -> One (Sub (r755) :: r784) - | 970 -> One (Sub (r781) :: r783) - | 1293 -> One (Sub (r793) :: r1017) - | 1317 -> One (Sub (r793) :: r1026) - | 1257 -> One (Sub (r845) :: r1003) - | 1244 -> One (Sub (r905) :: r986) - | 1321 -> One (Sub (r908) :: r1027) - | 1162 -> One (Sub (r926) :: r928) - | 1190 -> One (Sub (r945) :: r947) - | 1477 -> One (Sub (r1080) :: r1082) - | 660 -> One (r0) - | 1756 -> One (r2) - | 1755 -> One (r3) - | 1754 -> One (r4) - | 1753 -> One (r5) - | 1752 -> One (r6) - | 58 -> One (r7) - | 53 -> One (r8) - | 54 -> One (r10) - | 57 -> One (r12) - | 56 -> One (r13) - | 1358 -> One (r14) - | 1751 -> One (r16) - | 1750 -> One (r17) - | 60 -> One (r18) - | 1749 -> One (r19) - | 1748 -> One (r20) - | 1747 -> One (r21) - | 1746 -> One (r22) - | 63 -> One (r23) - | 62 -> One (r24) - | 64 -> One (r25) - | 65 -> One (r26) - | 1739 -> One (r27) - | 68 -> One (r28) - | 67 -> One (r29) - | 1536 -> One (r30) - | 1534 -> One (r31) - | 568 -> One (r32) - | 1541 -> One (r34) - | 1738 -> One (r36) - | 1737 -> One (r37) - | 1736 -> One (r38) - | 71 -> One (r39) - | 70 -> One (r40) - | 74 -> One (r41) - | 1615 -> One (r43) - | 1735 -> One (r44) - | 1734 -> One (r45) - | 1733 -> One (r46) - | 78 -> One (r47) - | 77 -> One (r48) - | 1729 -> One (r49) - | 1728 -> One (r50) - | 80 -> One (r51) - | 82 -> One (r52) - | 85 -> One (r53) - | 89 -> One (r54) - | 395 -> One (r55) - | 394 -> One (r56) - | 144 -> One (r57) - | 146 -> One (r59) - | 145 -> One (r60) - | 110 -> One (r61) - | 99 -> One (r62) - | 102 -> One (r64) - | 101 -> One (r65) - | 98 -> One (r66) - | 97 -> One (r67) - | 1727 -> One (r68) - | 1726 -> One (r69) - | 104 | 151 -> One (r70) - | 1150 -> One (r71) - | 1725 -> One (r73) - | 1724 -> One (r74) - | 106 -> One (r75) - | 147 | 246 | 552 | 1495 -> One (r76) - | 150 -> One (r78) - | 299 -> One (r80) - | 285 -> One (r82) - | 315 -> One (r84) - | 325 -> One (r86) - | 806 -> One (r88) - | 1723 -> One (r90) - | 1722 -> One (r91) - | 149 -> One (r92) - | 148 -> One (r93) - | 109 -> One (r94) - | 108 -> One (r95) - | 129 -> One (r96) - | 128 -> One (r97) - | 125 -> One (r98) - | 127 -> One (r99) - | 133 -> One (r100) - | 132 -> One (r101) - | 137 -> One (r102) - | 136 -> One (r103) - | 154 -> One (r104) - | 162 -> One (r106) - | 161 -> One (r107) - | 158 -> One (r109) - | 157 -> One (r110) - | 1721 -> One (r111) - | 1720 -> One (r112) - | 165 -> One (r113) - | 164 -> One (r114) - | 163 -> One (r115) - | 1719 -> One (r116) - | 169 -> One (r117) - | 168 -> One (r118) - | 167 -> One (r119) - | 1718 -> One (r120) - | 1717 -> One (r121) - | 172 -> One (r122) - | 205 -> One (r123) - | 289 -> One (r125) - | 351 -> One (r127) - | 862 -> One (r129) - | 898 -> One (r131) - | 897 -> One (r132) - | 896 | 1706 -> One (r133) - | 1702 -> One (r135) - | 1716 -> One (r137) - | 1715 -> One (r138) - | 1714 -> One (r139) - | 1713 -> One (r140) - | 1712 -> One (r141) - | 925 -> One (r145) - | 924 -> One (r146) - | 923 -> One (r147) - | 1699 -> One (r153) - | 1698 -> One (r154) - | 1692 -> One (r155) - | 1691 -> One (r156) - | 1690 -> One (r157) - | 907 -> One (r159) - | 906 -> One (r160) - | 905 -> One (r161) - | 188 -> One (r165) - | 191 -> One (r167) - | 187 -> One (r168) - | 192 -> One (r170) - | 194 -> One (r172) - | 193 -> One (r173) - | 190 -> One (r174) - | 196 -> One (r175) - | 875 -> One (r176) - | 1689 -> One (r178) - | 1686 -> One (r179) - | 813 -> One (r180) - | 812 -> One (r181) - | 1671 -> One (r182) - | 1670 -> One (r183) - | 1669 -> One (r184) - | 204 -> One (r185) - | 1666 -> One (r186) - | 829 -> One (r187) - | 1658 -> One (r189) - | 1657 -> One (r190) - | 208 -> One (r191) - | 1656 -> One (r192) - | 1655 -> One (r193) - | 210 -> One (r194) - | 1654 -> One (r195) - | 1650 -> One (r196) - | 1649 -> One (r197) - | 1648 -> One (r198) - | 1647 -> One (r199) - | 1646 -> One (r200) - | 1645 -> One (r201) - | 218 -> One (r202) - | 217 -> One (r203) - | 537 -> One (r204) - | 536 -> One (r205) - | 1635 -> One (r206) - | 1634 -> One (r207) - | 221 -> One (r208) - | 225 -> One (r209) - | 231 -> One (r211) - | 232 -> One (r213) - | 224 -> One (r214) - | 223 -> One (r215) - | 229 -> One (r216) - | 227 -> One (r217) - | 228 -> One (r218) - | 230 -> One (r219) - | 234 -> One (r220) - | 1633 -> One (r221) - | 1632 -> One (r222) - | 1631 -> One (r223) - | 239 -> One (r224) - | 238 -> One (r225) - | 1630 -> One (r226) - | 1629 -> One (r227) - | 1628 -> One (r228) - | 242 -> One (r229) - | 241 -> One (r230) - | 1625 -> One (r231) - | 1624 -> One (r232) - | 1612 -> One (r233) - | 1611 -> One (r234) - | 429 -> One (r235) - | 1610 -> One (r237) - | 1609 -> One (r238) - | 252 -> One (r239) - | 250 -> One (r240) - | 249 -> One (r241) - | 426 -> One (r242) - | 255 -> One (r243) - | 415 -> One (r244) - | 414 -> One (r246) - | 413 -> One (r247) - | 257 -> One (r248) - | 420 -> One (r250) - | 342 -> One (r251) - | 260 -> One (r252) - | 259 -> One (r254) - | 258 -> One (r255) - | 341 -> One (r256) - | 323 -> One (r257) - | 304 -> One (r259) - | 335 -> One (r261) - | 334 -> One (r262) - | 264 -> One (r263) - | 266 -> One (r264) - | 333 -> One (r265) + | 0 | 1907 | 1911 | 1929 | 1933 | 1937 | 1941 | 1945 | 1949 | 1953 | 1957 | 1961 | 1965 | 1971 | 1991 -> Nothing + | 1906 -> One ([R 0]) + | 1910 -> One ([R 1]) + | 1916 -> One ([R 2]) + | 1930 -> One ([R 3]) + | 1934 -> One ([R 4]) + | 1940 -> One ([R 5]) + | 1942 -> One ([R 6]) + | 1946 -> One ([R 7]) + | 1950 -> One ([R 8]) + | 1954 -> One ([R 9]) + | 1958 -> One ([R 10]) + | 1964 -> One ([R 11]) + | 1968 -> One ([R 12]) + | 1981 -> One ([R 13]) + | 2001 -> One ([R 14]) + | 218 -> One ([R 15]) + | 217 -> One ([R 16]) + | 1924 -> One ([R 20]) + | 1926 -> One ([R 21]) + | 298 -> One ([R 22]) + | 281 -> One ([R 23]) + | 304 -> One ([R 24]) + | 1693 -> One ([R 36]) + | 1697 -> One ([R 41]) + | 1694 -> One ([R 42]) + | 1733 -> One ([R 51]) + | 1700 -> One ([R 56]) + | 1464 -> One ([R 68]) + | 1444 -> One ([R 69]) + | 1446 -> One ([R 73]) + | 1695 -> One ([R 77]) + | 359 -> One ([R 88]) + | 185 -> One ([R 89]) + | 357 -> One ([R 90]) + | 158 -> One ([R 94]) + | 157 | 1150 -> One ([R 95]) + | 1321 -> One ([R 98]) + | 1546 -> One ([R 106]) + | 1550 -> One ([R 107]) + | 308 -> One ([R 109]) + | 286 -> One ([R 110]) + | 295 -> One ([R 111]) + | 297 -> One ([R 112]) + | 1063 -> One ([R 122]) + | 1 -> One (R 124 :: r9) + | 61 -> One (R 124 :: r42) + | 182 -> One (R 124 :: r179) + | 187 -> One (R 124 :: r186) + | 200 -> One (R 124 :: r199) + | 219 -> One (R 124 :: r213) + | 220 -> One (R 124 :: r217) + | 226 -> One (R 124 :: r229) + | 241 -> One (R 124 :: r239) + | 351 -> One (R 124 :: r334) + | 374 -> One (R 124 :: r347) + | 451 -> One (R 124 :: r399) + | 545 -> One (R 124 :: r471) + | 548 -> One (R 124 :: r474) + | 551 -> One (R 124 :: r479) + | 554 -> One (R 124 :: r482) + | 560 -> One (R 124 :: r502) + | 589 -> One (R 124 :: r516) + | 594 -> One (R 124 :: r520) + | 601 -> One (R 124 :: r533) + | 617 -> One (R 124 :: r544) + | 631 -> One (R 124 :: r550) + | 639 -> One (R 124 :: r558) + | 645 -> One (R 124 :: r562) + | 674 -> One (R 124 :: r582) + | 690 -> One (R 124 :: r588) + | 696 -> One (R 124 :: r592) + | 705 -> One (R 124 :: r596) + | 716 -> One (R 124 :: r602) + | 722 -> One (R 124 :: r606) + | 728 -> One (R 124 :: r610) + | 734 -> One (R 124 :: r614) + | 740 -> One (R 124 :: r618) + | 746 -> One (R 124 :: r622) + | 752 -> One (R 124 :: r626) + | 758 -> One (R 124 :: r630) + | 764 -> One (R 124 :: r634) + | 770 -> One (R 124 :: r638) + | 776 -> One (R 124 :: r642) + | 782 -> One (R 124 :: r646) + | 788 -> One (R 124 :: r650) + | 794 -> One (R 124 :: r654) + | 800 -> One (R 124 :: r658) + | 806 -> One (R 124 :: r662) + | 812 -> One (R 124 :: r666) + | 818 -> One (R 124 :: r670) + | 824 -> One (R 124 :: r674) + | 830 -> One (R 124 :: r678) + | 921 -> One (R 124 :: r730) + | 930 -> One (R 124 :: r737) + | 939 -> One (R 124 :: r744) + | 949 -> One (R 124 :: r748) + | 958 -> One (R 124 :: r752) + | 967 -> One (R 124 :: r756) + | 978 -> One (R 124 :: r760) + | 987 -> One (R 124 :: r764) + | 996 -> One (R 124 :: r768) + | 1003 -> One (R 124 :: r772) + | 1082 -> One (R 124 :: r790) + | 1087 -> One (R 124 :: r794) + | 1094 -> One (R 124 :: r798) + | 1103 -> One (R 124 :: r803) + | 1113 -> One (R 124 :: r806) + | 1132 -> One (R 124 :: r816) + | 1147 -> One (R 124 :: r827) + | 1207 -> One (R 124 :: r860) + | 1216 -> One (R 124 :: r865) + | 1231 -> One (R 124 :: r872) + | 1262 -> One (R 124 :: r889) + | 1295 -> One (R 124 :: r917) + | 1300 -> One (R 124 :: r927) + | 1332 -> One (R 124 :: r951) + | 1333 -> One (R 124 :: r955) + | 1342 -> One (R 124 :: r963) + | 1379 -> One (R 124 :: r991) + | 1388 -> One (R 124 :: r1005) + | 1389 -> One (R 124 :: r1014) + | 1583 -> One (R 124 :: r1131) + | 296 -> One ([R 130]) + | 649 -> One ([R 136]) + | 1009 -> One ([R 154]) + | 672 -> One ([R 155]) + | 703 -> One ([R 156]) + | 679 -> One ([R 157]) + | 701 -> One ([R 228]) + | 710 -> One ([R 233]) + | 714 -> One ([R 234]) + | 465 -> One ([R 242]) + | 114 -> One ([R 255]) + | 91 -> One (R 258 :: r53) + | 95 -> One (R 258 :: r55) + | 216 -> One ([R 262]) + | 1172 -> One ([R 266]) + | 1173 -> One ([R 267]) + | 1008 -> One ([R 271]) + | 886 -> One ([R 285]) + | 857 -> One ([R 287]) + | 891 -> One ([R 294]) + | 1698 -> One ([R 297]) + | 566 -> One ([R 298]) + | 1206 -> One ([R 300]) + | 128 -> One (R 316 :: r74) + | 213 -> One (R 316 :: r208) + | 224 -> One (R 316 :: r222) + | 237 -> One (R 316 :: r234) + | 454 -> One (R 316 :: r403) + | 463 -> One (R 316 :: r415) + | 835 -> One (R 316 :: r681) + | 1277 -> One (R 316 :: r905) + | 1361 -> One (R 316 :: r982) + | 1400 -> One (R 316 :: r1020) + | 1406 -> One (R 316 :: r1028) + | 1417 -> One (R 316 :: r1034) + | 1428 -> One (R 316 :: r1037) + | 1432 -> One (R 316 :: r1046) + | 1453 -> One (R 316 :: r1060) + | 1469 -> One (R 316 :: r1070) + | 1504 -> One (R 316 :: r1087) + | 1526 -> One (R 316 :: r1097) + | 1536 -> One (R 316 :: r1106) + | 1590 -> One (R 316 :: r1135) + | 1594 -> One (R 316 :: r1148) + | 1622 -> One (R 316 :: r1167) + | 1662 -> One (R 316 :: r1189) + | 1666 -> One (R 316 :: r1193) + | 1667 -> One (R 316 :: r1197) + | 1678 -> One (R 316 :: r1213) + | 1686 -> One (R 316 :: r1222) + | 1725 -> One (R 316 :: r1233) + | 1745 -> One (R 316 :: r1246) + | 1838 -> One (R 316 :: r1260) + | 1525 -> One (R 318 :: r1090) + | 1766 -> One (R 318 :: r1249) + | 1535 -> One (R 320 :: r1098) + | 888 -> One (R 322 :: r709) + | 1462 -> One (R 322 :: r1061) + | 1523 -> One (R 322 :: r1089) + | 1731 -> One (R 322 :: r1234) + | 1764 -> One (R 322 :: r1248) + | 1771 -> One (R 322 :: r1251) + | 1781 -> One (R 322 :: r1253) + | 1986 -> One (R 322 :: r1297) + | 1997 -> One (R 322 :: r1303) + | 2002 -> One (R 322 :: r1306) + | 1331 -> One (R 324 :: r947) + | 1515 -> One (R 324 :: r1088) + | 215 -> One (R 327 :: r209) + | 1755 -> One (R 327 :: r1247) + | 1465 -> One (R 331 :: r1062) + | 1734 -> One (R 333 :: r1235) + | 1984 -> One (R 335 :: r1295) + | 1992 -> One (R 337 :: r1299) + | 1993 -> One (R 337 :: r1300) + | 1994 -> One (R 337 :: r1301) + | 428 -> One ([R 343]) + | 432 -> One ([R 345]) + | 1076 -> One ([R 348]) + | 1841 -> One ([R 349]) + | 1844 -> One ([R 350]) + | 1843 -> One ([R 352]) + | 1842 -> One ([R 354]) + | 1840 -> One ([R 355]) + | 1925 -> One ([R 367]) + | 1915 -> One ([R 369]) + | 1923 -> One ([R 370]) + | 1922 -> One ([R 372]) + | 608 -> One ([R 379]) + | 1061 -> One ([R 380]) + | 522 -> One ([R 391]) + | 532 -> One ([R 392]) + | 533 -> One ([R 393]) + | 531 -> One ([R 394]) + | 534 -> One ([R 396]) + | 212 -> One ([R 397]) + | 204 | 1352 -> One ([R 398]) + | 492 -> One ([R 405]) + | 469 -> One ([R 406]) + | 499 -> One ([R 410]) + | 1158 | 1608 -> One ([R 415]) + | 1410 -> One ([R 417]) + | 1408 -> One ([R 418]) + | 1411 -> One ([R 419]) + | 1409 -> One ([R 420]) + | 392 -> One ([R 423]) + | 1311 -> One ([R 425]) + | 1559 -> One ([R 426]) + | 1865 -> One ([R 427]) + | 1575 -> One ([R 428]) + | 1866 -> One ([R 429]) + | 1574 -> One ([R 430]) + | 1566 -> One ([R 431]) + | 66 | 245 -> One ([R 446]) + | 74 | 626 -> One ([R 447]) + | 102 -> One ([R 448]) + | 90 -> One ([R 450]) + | 94 -> One ([R 452]) + | 98 -> One ([R 454]) + | 81 -> One ([R 455]) + | 101 | 1032 -> One ([R 456]) + | 80 -> One ([R 457]) + | 79 -> One ([R 458]) + | 78 -> One ([R 459]) + | 77 -> One ([R 460]) + | 76 -> One ([R 461]) + | 69 | 199 | 616 -> One ([R 462]) + | 68 | 615 -> One ([R 463]) + | 67 -> One ([R 464]) + | 73 | 398 | 625 -> One ([R 465]) + | 72 | 624 -> One ([R 466]) + | 65 -> One ([R 467]) + | 70 -> One ([R 468]) + | 83 -> One ([R 469]) + | 75 -> One ([R 470]) + | 82 -> One ([R 471]) + | 71 -> One ([R 472]) + | 100 -> One ([R 473]) + | 103 -> One ([R 474]) + | 99 -> One ([R 476]) + | 324 -> One ([R 477]) + | 323 -> One (R 478 :: r319) + | 259 -> One (R 479 :: r272) + | 260 -> One ([R 480]) + | 429 -> One (R 481 :: r368) + | 430 -> One ([R 482]) + | 858 -> One (R 498 :: r698) + | 859 -> One ([R 499]) + | 120 -> One ([R 500]) + | 384 -> One ([R 524]) + | 378 -> One ([R 525]) + | 379 -> One ([R 527]) + | 377 | 627 -> One ([R 534]) + | 881 -> One ([R 540]) + | 882 -> One ([R 541]) + | 883 -> One ([R 543]) + | 572 -> One ([R 545]) + | 1582 -> One ([R 549]) + | 1624 | 1643 -> One ([R 559]) + | 1421 -> One ([R 561]) + | 1419 -> One ([R 562]) + | 1422 -> One ([R 563]) + | 1420 -> One ([R 564]) + | 1707 -> One (R 565 :: r1227) + | 1198 -> One ([R 566]) + | 1557 -> One ([R 569]) + | 1558 -> One ([R 570]) + | 1552 -> One ([R 571]) + | 1818 -> One ([R 573]) + | 1817 -> One ([R 574]) + | 1819 -> One ([R 575]) + | 1814 -> One ([R 576]) + | 1815 -> One ([R 577]) + | 1879 -> One ([R 579]) + | 1877 -> One ([R 580]) + | 583 -> One ([R 584]) + | 514 -> One ([R 585]) + | 466 -> One ([R 586]) + | 1011 -> One ([R 587]) + | 1010 -> One ([R 588]) + | 346 -> One ([R 590]) + | 316 -> One ([R 618]) + | 905 -> One ([R 621]) + | 643 -> One ([R 623]) + | 906 -> One ([R 624]) + | 1013 -> One ([R 625]) + | 1119 -> One ([R 627]) + | 1120 -> One ([R 628]) + | 423 -> One ([R 630]) + | 424 -> One ([R 631]) + | 1053 -> One ([R 633]) + | 1054 -> One ([R 634]) + | 1577 -> One ([R 640]) + | 1514 -> One ([R 641]) + | 1517 -> One ([R 642]) + | 1516 -> One ([R 647]) + | 1521 -> One ([R 650]) + | 1520 -> One ([R 652]) + | 1519 -> One ([R 653]) + | 1518 -> One ([R 654]) + | 1578 -> One ([R 657]) + | 197 -> One ([R 660]) + | 194 -> One ([R 662]) + | 607 -> One ([R 687]) + | 683 -> One ([R 688]) + | 682 | 702 -> One ([R 689]) + | 610 | 678 -> One ([R 690]) + | 913 | 1001 -> One ([R 695]) + | 681 -> One ([R 700]) + | 360 -> One ([R 713]) + | 364 -> One ([R 716]) + | 365 -> One ([R 720]) + | 396 -> One ([R 722]) + | 369 -> One ([R 723]) + | 425 -> One ([R 725]) + | 387 -> One ([R 730]) + | 28 -> One ([R 731]) + | 8 -> One ([R 732]) + | 52 -> One ([R 734]) + | 51 -> One ([R 735]) + | 50 -> One ([R 736]) + | 49 -> One ([R 737]) + | 48 -> One ([R 738]) + | 47 -> One ([R 739]) + | 46 -> One ([R 740]) + | 45 -> One ([R 741]) + | 44 -> One ([R 742]) + | 43 -> One ([R 743]) + | 42 -> One ([R 744]) + | 41 -> One ([R 745]) + | 40 -> One ([R 746]) + | 39 -> One ([R 747]) + | 38 -> One ([R 748]) + | 37 -> One ([R 749]) + | 36 -> One ([R 750]) + | 35 -> One ([R 751]) + | 34 -> One ([R 752]) + | 33 -> One ([R 753]) + | 32 -> One ([R 754]) + | 31 -> One ([R 755]) + | 30 -> One ([R 756]) + | 29 -> One ([R 757]) + | 27 -> One ([R 758]) + | 26 -> One ([R 759]) + | 25 -> One ([R 760]) + | 24 -> One ([R 761]) + | 23 -> One ([R 762]) + | 22 -> One ([R 763]) + | 21 -> One ([R 764]) + | 20 -> One ([R 765]) + | 19 -> One ([R 766]) + | 18 -> One ([R 767]) + | 17 -> One ([R 768]) + | 16 -> One ([R 769]) + | 15 -> One ([R 770]) + | 14 -> One ([R 771]) + | 13 -> One ([R 772]) + | 12 -> One ([R 773]) + | 11 -> One ([R 774]) + | 10 -> One ([R 775]) + | 9 -> One ([R 776]) + | 7 -> One ([R 777]) + | 6 -> One ([R 778]) + | 5 -> One ([R 779]) + | 4 -> One ([R 780]) + | 3 -> One ([R 781]) + | 1758 -> One ([R 782]) + | 1775 -> One ([R 786]) + | 1763 | 1776 -> One ([R 788]) + | 1768 -> One ([R 790]) + | 1759 -> One ([R 791]) + | 1754 -> One ([R 792]) + | 1757 -> One ([R 796]) + | 1761 -> One ([R 799]) + | 1760 -> One ([R 800]) + | 1769 -> One ([R 802]) + | 240 -> One ([R 804]) + | 239 -> One ([R 805]) + | 1975 -> One ([R 809]) + | 1976 -> One ([R 810]) + | 1978 -> One ([R 811]) + | 1979 -> One ([R 812]) + | 1977 -> One ([R 813]) + | 1974 -> One ([R 814]) + | 1980 -> One ([R 818]) + | 284 -> One ([R 820]) + | 472 -> One (R 828 :: r432) + | 486 -> One ([R 829]) + | 134 -> One ([R 834]) + | 137 -> One ([R 835]) + | 141 -> One ([R 836]) + | 135 -> One ([R 837]) + | 142 -> One ([R 838]) + | 138 -> One ([R 839]) + | 143 -> One ([R 840]) + | 140 -> One ([R 841]) + | 133 -> One ([R 842]) + | 361 -> One ([R 847]) + | 680 -> One ([R 848]) + | 1392 -> One ([R 856]) + | 1606 -> One ([R 857]) + | 1609 -> One ([R 858]) + | 1607 -> One ([R 859]) + | 1641 -> One ([R 860]) + | 1644 -> One ([R 861]) + | 1642 -> One ([R 862]) + | 475 -> One ([R 869]) + | 476 -> One ([R 870]) + | 1047 -> One (S (T T_WITH) :: r787) + | 208 -> One (S (T T_TYPE) :: r205) + | 1175 -> One (S (T T_STAR) :: r850) + | 1982 -> One (S (T T_SEMISEMI) :: r1294) + | 1989 -> One (S (T T_SEMISEMI) :: r1298) + | 1912 -> One (S (T T_RPAREN) :: r134) + | 306 | 1858 -> One (S (T T_RPAREN) :: r311) + | 372 -> One (S (T T_RPAREN) :: r344) + | 416 -> One (S (T T_RPAREN) :: r367) + | 456 -> One (S (T T_RPAREN) :: r404) + | 524 -> One (S (T T_RPAREN) :: r447) + | 1033 -> One (S (T T_RPAREN) :: r776) + | 1226 -> One (S (T T_RPAREN) :: r868) + | 1851 -> One (S (T T_RPAREN) :: r1263) + | 1913 -> One (S (T T_RPAREN) :: r1277) + | 1154 | 1541 -> One (S (T T_RBRACKET) :: r252) + | 1039 -> One (S (T T_RBRACKET) :: r779) + | 1041 -> One (S (T T_RBRACKET) :: r780) + | 310 -> One (S (T T_QUOTE) :: r313) + | 1430 -> One (S (T T_OPEN) :: r1042) + | 1670 -> One (S (T T_OPEN) :: r1204) + | 121 | 289 -> One (S (T T_MODULE) :: r69) + | 461 -> One (S (T T_MINUSGREATER) :: r411) + | 1183 -> One (S (T T_MINUSGREATER) :: r855) + | 1187 -> One (S (T T_MINUSGREATER) :: r857) + | 1491 -> One (S (T T_MINUSGREATER) :: r1076) + | 84 -> One (S (T T_LPAREN) :: r50) + | 117 -> One (S (T T_LIDENT) :: r64) + | 437 -> One (S (T T_LIDENT) :: r370) + | 445 -> One (S (T T_LIDENT) :: r376) + | 650 -> One (S (T T_LIDENT) :: r563) + | 651 -> One (S (T T_LIDENT) :: r569) + | 662 -> One (S (T T_LIDENT) :: r572) + | 666 -> One (S (T T_LIDENT) :: r574) + | 1159 -> One (S (T T_LIDENT) :: r846) + | 1610 -> One (S (T T_LIDENT) :: r1153) + | 1645 -> One (S (T T_LIDENT) :: r1178) + | 1717 -> One (S (T T_LIDENT) :: r1230) + | 192 -> One (S (T T_INT) :: r190) + | 195 -> One (S (T T_INT) :: r191) + | 684 -> One (S (T T_IN) :: r584) + | 1690 -> One (S (T T_IN) :: r1224) + | 538 -> One (S (T T_GREATERRBRACE) :: r454) + | 1122 -> One (S (T T_GREATERRBRACE) :: r807) + | 165 -> One (S (T T_GREATER) :: r139) + | 1846 -> One (S (T T_GREATER) :: r1261) + | 504 -> One (S (T T_EQUAL) :: r443) + | 854 -> One (S (T T_EQUAL) :: r695) + | 870 -> One (S (T T_EQUAL) :: r703) + | 1023 -> One (S (T T_EQUAL) :: r774) + | 1600 -> One (S (T T_EQUAL) :: r1150) + | 1618 -> One (S (T T_EQUAL) :: r1155) + | 1904 -> One (S (T T_EOF) :: r1275) + | 1908 -> One (S (T T_EOF) :: r1276) + | 1927 -> One (S (T T_EOF) :: r1282) + | 1931 -> One (S (T T_EOF) :: r1283) + | 1935 -> One (S (T T_EOF) :: r1284) + | 1938 -> One (S (T T_EOF) :: r1285) + | 1943 -> One (S (T T_EOF) :: r1286) + | 1947 -> One (S (T T_EOF) :: r1287) + | 1951 -> One (S (T T_EOF) :: r1288) + | 1955 -> One (S (T T_EOF) :: r1289) + | 1959 -> One (S (T T_EOF) :: r1290) + | 1962 -> One (S (T T_EOF) :: r1291) + | 1966 -> One (S (T T_EOF) :: r1292) + | 2006 -> One (S (T T_EOF) :: r1307) + | 1100 -> One (S (T T_END) :: r799) + | 86 -> One (S (T T_DOTDOT) :: r51) + | 159 -> One (S (T T_DOTDOT) :: r131) + | 1560 -> One (S (T T_DOTDOT) :: r1113) + | 1561 -> One (S (T T_DOTDOT) :: r1114) + | 230 | 899 | 972 -> One (S (T T_DOT) :: r231) + | 1969 -> One (S (T T_DOT) :: r444) + | 847 -> One (S (T T_DOT) :: r692) + | 1162 -> One (S (T T_DOT) :: r848) + | 1181 -> One (S (T T_DOT) :: r853) + | 1305 -> One (S (T T_DOT) :: r929) + | 1917 -> One (S (T T_DOT) :: r1281) + | 160 | 1151 -> One (S (T T_COLONCOLON) :: r133) + | 166 -> One (S (T T_COLON) :: r144) + | 458 -> One (S (T T_COLON) :: r407) + | 1485 -> One (S (T T_COLON) :: r1074) + | 246 -> One (S (T T_BARRBRACKET) :: r242) + | 250 -> One (S (T T_BARRBRACKET) :: r251) + | 434 -> One (S (T T_BARRBRACKET) :: r369) + | 1035 -> One (S (T T_BARRBRACKET) :: r777) + | 1037 -> One (S (T T_BARRBRACKET) :: r778) + | 1213 -> One (S (T T_BARRBRACKET) :: r861) + | 335 -> One (S (T T_BAR) :: r323) + | 190 -> One (S (N N_pattern) :: r188) + | 389 | 574 -> One (S (N N_pattern) :: r193) + | 350 -> One (S (N N_pattern) :: r328) + | 380 -> One (S (N N_pattern) :: r348) + | 382 -> One (S (N N_pattern) :: r349) + | 403 -> One (S (N N_pattern) :: r360) + | 408 -> One (S (N N_pattern) :: r363) + | 873 -> One (S (N N_pattern) :: r704) + | 875 -> One (S (N N_pattern) :: r705) + | 877 -> One (S (N N_pattern) :: r706) + | 884 -> One (S (N N_pattern) :: r708) + | 1289 -> One (S (N N_pattern) :: r909) + | 207 -> One (S (N N_module_type) :: r201) + | 460 -> One (S (N N_module_type) :: r409) + | 500 -> One (S (N N_module_type) :: r440) + | 502 -> One (S (N N_module_type) :: r441) + | 528 -> One (S (N N_module_type) :: r449) + | 1138 -> One (S (N N_module_type) :: r819) + | 1221 -> One (S (N N_module_type) :: r867) + | 1236 -> One (S (N N_module_type) :: r874) + | 1239 -> One (S (N N_module_type) :: r876) + | 1242 -> One (S (N N_module_type) :: r878) + | 1247 -> One (S (N N_module_type) :: r880) + | 1250 -> One (S (N N_module_type) :: r882) + | 1253 -> One (S (N N_module_type) :: r884) + | 1267 -> One (S (N N_module_type) :: r896) + | 223 -> One (S (N N_module_expr) :: r219) + | 565 -> One (S (N N_let_pattern) :: r508) + | 248 -> One (S (N N_fun_expr) :: r243) + | 540 -> One (S (N N_fun_expr) :: r457) + | 544 -> One (S (N N_fun_expr) :: r468) + | 593 -> One (S (N N_fun_expr) :: r517) + | 644 -> One (S (N N_fun_expr) :: r559) + | 673 -> One (S (N N_fun_expr) :: r579) + | 689 -> One (S (N N_fun_expr) :: r585) + | 695 -> One (S (N N_fun_expr) :: r589) + | 704 -> One (S (N N_fun_expr) :: r593) + | 715 -> One (S (N N_fun_expr) :: r599) + | 721 -> One (S (N N_fun_expr) :: r603) + | 727 -> One (S (N N_fun_expr) :: r607) + | 733 -> One (S (N N_fun_expr) :: r611) + | 739 -> One (S (N N_fun_expr) :: r615) + | 745 -> One (S (N N_fun_expr) :: r619) + | 751 -> One (S (N N_fun_expr) :: r623) + | 757 -> One (S (N N_fun_expr) :: r627) + | 763 -> One (S (N N_fun_expr) :: r631) + | 769 -> One (S (N N_fun_expr) :: r635) + | 775 -> One (S (N N_fun_expr) :: r639) + | 781 -> One (S (N N_fun_expr) :: r643) + | 787 -> One (S (N N_fun_expr) :: r647) + | 793 -> One (S (N N_fun_expr) :: r651) + | 799 -> One (S (N N_fun_expr) :: r655) + | 805 -> One (S (N N_fun_expr) :: r659) + | 811 -> One (S (N N_fun_expr) :: r663) + | 817 -> One (S (N N_fun_expr) :: r667) + | 823 -> One (S (N N_fun_expr) :: r671) + | 829 -> One (S (N N_fun_expr) :: r675) + | 920 -> One (S (N N_fun_expr) :: r727) + | 929 -> One (S (N N_fun_expr) :: r734) + | 938 -> One (S (N N_fun_expr) :: r741) + | 948 -> One (S (N N_fun_expr) :: r745) + | 957 -> One (S (N N_fun_expr) :: r749) + | 966 -> One (S (N N_fun_expr) :: r753) + | 977 -> One (S (N N_fun_expr) :: r757) + | 986 -> One (S (N N_fun_expr) :: r761) + | 995 -> One (S (N N_fun_expr) :: r765) + | 1002 -> One (S (N N_fun_expr) :: r769) + | 1086 -> One (S (N N_fun_expr) :: r791) + | 1093 -> One (S (N N_fun_expr) :: r795) + | 448 -> One (Sub (r3) :: r380) + | 559 -> One (Sub (r3) :: r486) + | 1291 -> One (Sub (r3) :: r910) + | 2 -> One (Sub (r13) :: r14) + | 55 -> One (Sub (r13) :: r15) + | 59 -> One (Sub (r13) :: r22) + | 168 -> One (Sub (r13) :: r147) + | 180 -> One (Sub (r13) :: r168) + | 711 -> One (Sub (r13) :: r598) + | 1287 -> One (Sub (r13) :: r908) + | 1293 -> One (Sub (r13) :: r913) + | 1671 -> One (Sub (r13) :: r1209) + | 410 -> One (Sub (r24) :: r364) + | 879 -> One (Sub (r24) :: r707) + | 285 -> One (Sub (r26) :: r301) + | 300 -> One (Sub (r26) :: r309) + | 585 -> One (Sub (r26) :: r513) + | 1180 -> One (Sub (r26) :: r851) + | 290 -> One (Sub (r28) :: r308) + | 1493 -> One (Sub (r28) :: r1079) + | 283 -> One (Sub (r30) :: r300) + | 327 -> One (Sub (r32) :: r320) + | 479 -> One (Sub (r32) :: r434) + | 258 -> One (Sub (r34) :: r265) + | 405 -> One (Sub (r34) :: r362) + | 440 -> One (Sub (r34) :: r375) + | 482 -> One (Sub (r34) :: r437) + | 567 -> One (Sub (r34) :: r509) + | 628 -> One (Sub (r34) :: r547) + | 653 -> One (Sub (r34) :: r570) + | 657 -> One (Sub (r34) :: r571) + | 866 -> One (Sub (r34) :: r701) + | 1402 -> One (Sub (r34) :: r1022) + | 1440 -> One (Sub (r34) :: r1053) + | 1792 -> One (Sub (r34) :: r1255) + | 1856 -> One (Sub (r34) :: r1265) + | 1859 -> One (Sub (r34) :: r1266) + | 1627 -> One (Sub (r36) :: r1170) + | 1651 -> One (Sub (r36) :: r1181) + | 146 -> One (Sub (r59) :: r126) + | 848 -> One (Sub (r59) :: r693) + | 1972 -> One (Sub (r59) :: r1293) + | 1330 -> One (Sub (r71) :: r946) + | 355 -> One (Sub (r86) :: r336) + | 152 -> One (Sub (r121) :: r127) + | 139 -> One (Sub (r123) :: r125) + | 1394 -> One (Sub (r123) :: r1016) + | 156 -> One (Sub (r129) :: r130) + | 1868 -> One (Sub (r129) :: r1271) + | 1882 -> One (Sub (r129) :: r1274) + | 557 -> One (Sub (r172) :: r483) + | 598 -> One (Sub (r172) :: r521) + | 186 -> One (Sub (r180) :: r181) + | 543 -> One (Sub (r180) :: r466) + | 606 -> One (Sub (r180) :: r534) + | 635 -> One (Sub (r180) :: r551) + | 664 -> One (Sub (r180) :: r573) + | 914 -> One (Sub (r180) :: r726) + | 1273 -> One (Sub (r195) :: r900) + | 1356 -> One (Sub (r195) :: r976) + | 1029 -> One (Sub (r245) :: r775) + | 249 -> One (Sub (r247) :: r250) + | 253 -> One (Sub (r262) :: r264) + | 320 -> One (Sub (r267) :: r314) + | 264 -> One (Sub (r269) :: r276) + | 278 -> One (Sub (r269) :: r299) + | 265 -> One (Sub (r282) :: r284) + | 266 -> One (Sub (r286) :: r287) + | 302 -> One (Sub (r286) :: r310) + | 1853 -> One (Sub (r286) :: r1264) + | 268 -> One (Sub (r293) :: r295) + | 508 -> One (Sub (r293) :: r445) + | 1353 -> One (Sub (r293) :: r971) + | 343 -> One (Sub (r325) :: r327) + | 578 -> One (Sub (r331) :: r512) + | 366 -> One (Sub (r339) :: r340) + | 390 -> One (Sub (r353) :: r356) + | 575 -> One (Sub (r353) :: r511) + | 841 -> One (Sub (r353) :: r688) + | 1628 -> One (Sub (r353) :: r1175) + | 1652 -> One (Sub (r353) :: r1186) + | 438 -> One (Sub (r372) :: r374) + | 446 -> One (Sub (r372) :: r379) + | 512 -> One (Sub (r425) :: r446) + | 471 -> One (Sub (r427) :: r428) + | 541 -> One (Sub (r463) :: r465) + | 1046 -> One (Sub (r463) :: r785) + | 563 -> One (Sub (r504) :: r505) + | 1043 -> One (Sub (r781) :: r783) + | 1145 -> One (Sub (r810) :: r820) + | 1156 -> One (Sub (r829) :: r830) + | 1157 -> One (Sub (r838) :: r840) + | 1542 -> One (Sub (r838) :: r1108) + | 1562 -> One (Sub (r838) :: r1116) + | 1570 -> One (Sub (r838) :: r1118) + | 1861 -> One (Sub (r838) :: r1268) + | 1809 -> One (Sub (r930) :: r1257) + | 1821 -> One (Sub (r930) :: r1259) + | 1377 -> One (Sub (r958) :: r987) + | 1370 -> One (Sub (r984) :: r986) + | 1713 -> One (Sub (r996) :: r1229) + | 1737 -> One (Sub (r996) :: r1238) + | 1682 -> One (Sub (r1048) :: r1216) + | 1669 -> One (Sub (r1120) :: r1199) + | 1741 -> One (Sub (r1123) :: r1239) + | 1593 -> One (Sub (r1141) :: r1143) + | 1621 -> One (Sub (r1161) :: r1163) + | 688 -> One (r0) + | 687 -> One (r2) + | 1903 -> One (r4) + | 1902 -> One (r5) + | 1901 -> One (r6) + | 1900 -> One (r7) + | 1899 -> One (r8) + | 58 -> One (r9) + | 53 -> One (r10) + | 54 -> One (r12) + | 57 -> One (r14) + | 56 -> One (r15) + | 1770 -> One (r16) + | 1774 -> One (r18) + | 1898 -> One (r20) + | 1897 -> One (r21) + | 60 -> One (r22) + | 107 | 247 | 542 | 1060 -> One (r23) + | 110 -> One (r25) + | 299 -> One (r27) + | 282 -> One (r29) + | 305 -> One (r31) + | 309 -> One (r33) + | 1314 -> One (r35) + | 1896 -> One (r37) + | 1895 -> One (r38) + | 109 -> One (r39) + | 108 -> One (r40) + | 63 -> One (r41) + | 62 -> One (r42) + | 104 -> One (r43) + | 106 -> One (r45) + | 105 -> One (r46) + | 64 -> One (r47) + | 89 -> One (r48) + | 88 -> One (r49) + | 85 -> One (r50) + | 87 -> One (r51) + | 93 -> One (r52) + | 92 -> One (r53) + | 97 -> One (r54) + | 96 -> One (r55) + | 111 | 127 -> One (r56) + | 112 -> One (r57) + | 115 -> One (r58) + | 123 -> One (r61) + | 122 -> One (r62) + | 119 -> One (r63) + | 118 -> One (r64) + | 1894 -> One (r65) + | 1893 -> One (r66) + | 126 -> One (r67) + | 125 -> One (r68) + | 124 -> One (r69) + | 1581 -> One (r70) + | 1892 -> One (r72) + | 1891 -> One (r73) + | 129 -> One (r74) + | 1828 -> One (r75) + | 1827 -> One (r76) + | 1826 -> One (r77) + | 164 -> One (r83) + | 293 -> One (r85) + | 358 -> One (r87) + | 1195 -> One (r89) + | 1569 -> One (r91) + | 1568 -> One (r92) + | 1567 | 1820 -> One (r93) + | 1878 -> One (r95) + | 1890 -> One (r97) + | 1889 -> One (r98) + | 1888 -> One (r99) + | 1887 -> One (r100) + | 1886 -> One (r101) + | 1803 -> One (r105) + | 179 -> One (r106) + | 178 -> One (r107) + | 1876 -> One (r111) + | 1875 -> One (r112) + | 1874 -> One (r113) + | 1873 -> One (r114) + | 1872 -> One (r115) + | 145 -> One (r117) + | 148 -> One (r119) + | 144 -> One (r120) + | 149 -> One (r122) + | 151 -> One (r124) + | 150 -> One (r125) + | 147 -> One (r126) + | 153 -> One (r127) + | 1545 -> One (r128) + | 1867 -> One (r130) + | 1864 -> One (r131) + | 1153 -> One (r132) + | 1152 -> One (r133) + | 161 -> One (r134) + | 1850 -> One (r135) + | 1849 -> One (r136) + | 1848 -> One (r137) + | 163 -> One (r138) + | 1845 -> One (r139) + | 1169 -> One (r140) + | 1837 -> One (r142) + | 1836 -> One (r143) + | 167 -> One (r144) + | 1835 -> One (r145) + | 1834 -> One (r146) + | 169 -> One (r147) + | 170 -> One (r148) + | 171 -> One (r149) + | 1816 -> One (r150) + | 1833 -> One (r152) + | 1832 -> One (r153) + | 1831 -> One (r154) + | 1830 -> One (r155) + | 1829 -> One (r156) + | 1813 -> One (r160) + | 1812 -> One (r161) + | 1806 -> One (r162) + | 1805 -> One (r163) + | 1804 -> One (r164) + | 1802 -> One (r166) + | 1801 -> One (r167) + | 181 -> One (r168) + | 1077 -> One (r169) + | 1075 -> One (r170) + | 558 -> One (r171) + | 600 -> One (r173) + | 1800 -> One (r175) + | 1799 -> One (r176) + | 1798 -> One (r177) + | 184 -> One (r178) + | 183 -> One (r179) + | 1215 -> One (r181) + | 1797 -> One (r182) + | 1796 -> One (r183) + | 1795 -> One (r184) + | 189 -> One (r185) + | 188 -> One (r186) + | 1791 -> One (r187) + | 1790 -> One (r188) + | 191 -> One (r189) + | 193 -> One (r190) + | 196 -> One (r191) + | 402 -> One (r192) + | 401 -> One (r193) + | 203 -> One (r194) + | 206 -> One (r196) + | 205 -> One (r197) + | 202 -> One (r198) + | 201 -> One (r199) + | 1789 -> One (r200) + | 1788 -> One (r201) + | 1787 -> One (r202) + | 211 -> One (r203) + | 210 -> One (r204) + | 209 -> One (r205) + | 1786 -> One (r206) + | 1785 -> One (r207) + | 214 -> One (r208) + | 1784 -> One (r209) + | 1261 -> One (r210) + | 1260 -> One (r211) + | 1259 -> One (r212) + | 1258 -> One (r213) + | 1257 -> One (r214) + | 1256 -> One (r215) + | 222 -> One (r216) + | 221 -> One (r217) + | 527 -> One (r218) + | 526 -> One (r219) + | 1246 -> One (r220) + | 1245 -> One (r221) + | 225 -> One (r222) + | 229 -> One (r223) + | 235 -> One (r225) + | 236 -> One (r227) + | 228 -> One (r228) + | 227 -> One (r229) + | 233 -> One (r230) + | 231 -> One (r231) + | 232 -> One (r232) + | 234 -> One (r233) + | 238 -> One (r234) + | 1230 -> One (r235) + | 1229 -> One (r236) + | 1228 -> One (r237) + | 243 -> One (r238) + | 242 -> One (r239) + | 1225 -> One (r240) + | 1224 -> One (r241) + | 1212 -> One (r242) + | 1211 -> One (r243) + | 436 -> One (r244) + | 1031 -> One (r246) + | 1028 -> One (r248) + | 1027 -> One (r249) + | 1026 -> One (r250) + | 433 -> One (r251) + | 252 -> One (r252) + | 422 -> One (r253) + | 421 -> One (r255) + | 420 -> One (r256) + | 254 -> One (r257) + | 427 -> One (r259) + | 349 -> One (r260) + | 257 -> One (r261) + | 256 -> One (r263) + | 255 -> One (r264) + | 348 -> One (r265) | 332 -> One (r266) - | 283 -> One (r267) - | 282 -> One (r268) - | 322 -> One (r270) - | 309 -> One (r271) - | 327 -> One (r273) - | 326 -> One (r274) - | 279 | 1096 -> One (r275) + | 317 -> One (r268) + | 342 -> One (r270) + | 341 -> One (r271) + | 261 -> One (r272) + | 263 -> One (r273) + | 262 -> One (r274) + | 340 -> One (r275) + | 339 -> One (r276) | 280 -> One (r277) - | 275 -> One (r278) - | 274 -> One (r279) - | 278 -> One (r281) - | 276 -> One (r284) - | 273 -> One (r286) - | 272 -> One (r287) - | 306 -> One (r288) - | 305 -> One (r289) - | 302 -> One (r290) - | 291 -> One (r291) - | 293 -> One (r292) - | 298 -> One (r293) - | 297 -> One (r294) - | 296 -> One (r295) - | 301 -> One (r296) - | 308 -> One (r297) - | 321 -> One (r298) - | 320 -> One (r300) - | 313 -> One (r301) - | 312 -> One (r302) - | 316 -> One (r303) - | 319 -> One (r304) - | 318 -> One (r305) - | 331 -> One (r306) - | 330 -> One (r307) - | 329 -> One (r308) - | 340 -> One (r309) - | 338 -> One (r311) - | 337 -> One (r312) - | 419 -> One (r313) - | 355 | 717 -> One (r315) - | 356 -> One (r317) - | 346 -> One (r318) - | 345 -> One (r319) - | 347 -> One (r320) - | 349 -> One (r321) - | 361 -> One (r323) - | 360 -> One (r325) - | 412 -> One (r326) - | 411 -> One (r327) - | 364 -> One (r328) - | 366 -> One (r329) - | 406 -> One (r330) - | 369 -> One (r331) - | 368 -> One (r332) - | 374 -> One (r333) - | 376 -> One (r334) - | 379 -> One (r335) - | 405 -> One (r336) - | 384 -> One (r337) - | 388 -> One (r339) - | 387 -> One (r340) - | 386 -> One (r341) - | 390 -> One (r342) - | 393 -> One (r343) - | 392 -> One (r344) - | 397 -> One (r345) - | 400 -> One (r346) - | 399 -> One (r347) - | 402 -> One (r348) - | 404 -> One (r349) - | 408 -> One (r350) - | 407 -> One (r351) - | 410 -> One (r352) - | 424 -> One (r353) - | 428 -> One (r354) - | 437 -> One (r355) - | 432 -> One (r356) - | 436 -> One (r358) - | 435 -> One (r359) - | 434 -> One (r360) - | 1592 -> One (r361) - | 1591 -> One (r362) - | 1590 -> One (r363) - | 440 -> One (r364) - | 1589 -> One (r365) - | 443 -> One (r366) - | 1465 -> One (r368) - | 1462 -> One (r370) - | 1461 -> One (r371) - | 1460 -> One (r372) - | 445 -> One (r373) - | 454 -> One (r375) - | 452 -> One (r376) - | 451 -> One (r377) - | 450 -> One (r378) - | 449 -> One (r379) - | 1586 -> One (r380) - | 461 -> One (r381) - | 1211 -> One (r383) - | 1587 -> One (r385) - | 458 -> One (r386) - | 457 -> One (r387) - | 456 -> One (r388) - | 460 -> One (r389) - | 1570 -> One (r390) - | 1569 -> One (r391) - | 1568 -> One (r392) - | 1567 -> One (r393) - | 1566 -> One (r394) - | 463 -> One (r395) - | 1341 -> One (r396) - | 1340 -> One (r397) - | 1339 -> One (r398) - | 1338 -> One (r399) - | 1337 -> One (r400) - | 1336 -> One (r401) - | 1565 -> One (r402) - | 546 -> One (r403) - | 545 -> One (r404) - | 466 -> One (r405) - | 465 -> One (r406) - | 533 -> One (r407) - | 531 -> One (r408) - | 530 -> One (r409) - | 468 -> One (r410) - | 470 -> One (r411) - | 529 -> One (r412) - | 528 -> One (r413) - | 472 -> One (r414) - | 527 -> One (r415) - | 526 -> One (r416) - | 481 -> One (r417) - | 479 -> One (r418) - | 478 -> One (r419) - | 475 -> One (r420) - | 509 -> One (r421) - | 508 -> One (r423) - | 502 -> One (r425) - | 501 -> One (r426) - | 500 -> One (r427) - | 499 -> One (r428) - | 498 -> One (r429) - | 521 -> One (r431) - | 522 -> One (r433) - | 489 -> One (r434) - | 488 -> One (r435) - | 485 -> One (r436) - | 484 -> One (r437) - | 492 -> One (r438) - | 491 -> One (r439) - | 496 -> One (r440) - | 495 -> One (r441) - | 494 -> One (r442) - | 507 -> One (r443) - | 512 -> One (r445) - | 514 -> One (r446) - | 517 -> One (r447) - | 516 -> One (r448) - | 518 | 1823 -> One (r449) - | 520 -> One (r450) - | 524 -> One (r451) - | 535 -> One (r452) - | 540 -> One (r453) - | 539 -> One (r454) - | 1384 -> One (r455) - | 1564 -> One (r457) - | 1563 -> One (r458) - | 1560 -> One (r459) - | 1557 -> One (r460) - | 549 -> One (r461) - | 1556 -> One (r462) - | 1487 -> One (r463) - | 1486 -> One (r464) - | 1484 -> One (r465) - | 1490 -> One (r467) - | 1555 -> One (r469) - | 1554 -> One (r470) - | 1553 -> One (r471) - | 1552 -> One (r472) - | 1551 -> One (r473) - | 1550 -> One (r474) - | 557 -> One (r475) - | 556 -> One (r476) - | 1547 -> One (r477) - | 560 -> One (r478) - | 559 -> One (r479) - | 1544 -> One (r480) - | 1543 -> One (r481) - | 1542 -> One (r482) - | 563 -> One (r483) - | 562 -> One (r484) - | 1538 -> One (r485) - | 566 -> One (r486) - | 565 -> One (r487) - | 1537 -> One (r488) - | 1533 -> One (r489) - | 1532 -> One (r490) - | 1531 -> One (r491) - | 1206 -> One (r492) - | 1516 -> One (r494) - | 577 -> One (r495) - | 1530 -> One (r497) - | 1529 -> One (r498) - | 572 -> One (r499) - | 571 -> One (r500) - | 1528 -> One (r501) - | 576 -> One (r502) - | 575 -> One (r503) - | 1508 -> One (r504) - | 1507 -> One (r505) - | 1506 -> One (r506) - | 1505 -> One (r507) - | 582 -> One (r508) - | 581 -> One (r509) - | 580 -> One (r510) - | 579 -> One (r511) - | 1499 -> One (r512) - | 1504 -> One (r514) - | 1503 -> One (r515) - | 1502 -> One (r516) - | 1501 -> One (r517) - | 1500 -> One (r518) - | 1497 -> One (r519) - | 587 -> One (r520) - | 586 -> One (r521) - | 585 -> One (r522) - | 584 -> One (r523) - | 591 -> One (r524) - | 596 -> One (r525) - | 595 -> One (r526) - | 594 | 1494 -> One (r527) - | 1493 -> One (r528) - | 605 -> One (r529) - | 604 -> One (r530) - | 603 -> One (r531) - | 602 -> One (r532) - | 601 -> One (r533) - | 600 -> One (r534) - | 1456 -> One (r535) - | 612 -> One (r536) - | 611 -> One (r537) - | 616 -> One (r538) - | 615 -> One (r539) - | 614 -> One (r540) - | 618 -> One (r541) - | 1397 | 1449 -> One (r542) - | 1396 | 1448 -> One (r543) - | 620 | 1395 -> One (r544) - | 619 | 1394 -> One (r545) - | 1447 -> One (r546) - | 634 -> One (r547) - | 629 -> One (r548) - | 628 | 1593 -> One (r549) - | 633 -> One (r551) - | 632 -> One (r552) - | 625 -> One (r553) - | 627 -> One (r554) - | 631 -> One (r555) - | 636 -> One (r556) - | 638 -> One (r557) + | 279 -> One (r278) + | 331 -> One (r280) + | 322 -> One (r281) + | 334 -> One (r283) + | 333 -> One (r284) + | 276 | 1496 -> One (r285) + | 277 -> One (r287) + | 275 -> One (r288) + | 274 -> One (r289) + | 267 -> One (r290) + | 273 -> One (r292) + | 270 -> One (r294) + | 269 -> One (r295) + | 272 -> One (r296) + | 271 -> One (r297) + | 319 -> One (r298) + | 318 -> One (r299) + | 315 -> One (r300) + | 314 -> One (r301) + | 313 -> One (r304) + | 294 -> One (r306) + | 292 -> One (r307) + | 291 -> One (r308) + | 301 -> One (r309) + | 303 -> One (r310) + | 307 -> One (r311) + | 312 -> One (r312) + | 311 -> One (r313) + | 321 -> One (r314) + | 330 -> One (r315) + | 329 -> One (r317) + | 326 -> One (r318) + | 325 -> One (r319) + | 328 -> One (r320) + | 338 -> One (r321) + | 337 -> One (r322) + | 336 -> One (r323) + | 347 -> One (r324) + | 345 -> One (r326) + | 344 -> One (r327) + | 426 -> One (r328) + | 362 | 865 -> One (r330) + | 363 -> One (r332) + | 353 -> One (r333) + | 352 -> One (r334) + | 354 -> One (r335) + | 356 -> One (r336) + | 368 -> One (r338) + | 367 -> One (r340) + | 419 -> One (r341) + | 418 -> One (r342) + | 371 -> One (r343) + | 373 -> One (r344) + | 413 -> One (r345) + | 376 -> One (r346) + | 375 -> One (r347) + | 381 -> One (r348) + | 383 -> One (r349) + | 386 -> One (r350) + | 412 -> One (r351) + | 391 -> One (r352) + | 395 -> One (r354) + | 394 -> One (r355) + | 393 -> One (r356) + | 397 -> One (r357) + | 400 -> One (r358) + | 399 -> One (r359) + | 404 -> One (r360) + | 407 -> One (r361) + | 406 -> One (r362) + | 409 -> One (r363) + | 411 -> One (r364) + | 415 -> One (r365) + | 414 -> One (r366) + | 417 -> One (r367) + | 431 -> One (r368) + | 435 -> One (r369) + | 444 -> One (r370) + | 439 -> One (r371) + | 443 -> One (r373) + | 442 -> One (r374) + | 441 -> One (r375) + | 1205 -> One (r376) + | 1204 -> One (r377) + | 1203 -> One (r378) + | 447 -> One (r379) + | 1202 -> One (r380) + | 1131 -> One (r381) + | 1130 -> One (r382) + | 1129 -> One (r383) + | 1128 -> One (r384) + | 1127 -> One (r385) + | 450 -> One (r386) + | 837 -> One (r387) + | 1201 -> One (r389) + | 1200 -> One (r390) + | 1199 -> One (r391) + | 1197 -> One (r392) + | 1196 -> One (r393) + | 1756 -> One (r394) + | 1126 -> One (r395) + | 536 -> One (r396) + | 535 -> One (r397) + | 453 -> One (r398) + | 452 -> One (r399) + | 523 -> One (r400) + | 521 -> One (r401) + | 520 -> One (r402) + | 455 -> One (r403) + | 457 -> One (r404) + | 519 -> One (r405) + | 518 -> One (r406) + | 459 -> One (r407) + | 517 -> One (r408) + | 516 -> One (r409) + | 515 -> One (r410) + | 462 -> One (r411) + | 470 -> One (r412) + | 468 -> One (r413) + | 467 -> One (r414) + | 464 -> One (r415) + | 498 -> One (r416) + | 497 -> One (r418) + | 491 -> One (r420) + | 490 -> One (r421) + | 489 -> One (r422) + | 488 -> One (r423) + | 487 -> One (r424) + | 510 -> One (r426) + | 511 -> One (r428) + | 478 -> One (r429) + | 477 -> One (r430) + | 474 -> One (r431) + | 473 -> One (r432) + | 481 -> One (r433) + | 480 -> One (r434) + | 485 -> One (r435) + | 484 -> One (r436) + | 483 -> One (r437) + | 496 -> One (r438) + | 501 -> One (r440) + | 503 -> One (r441) + | 506 -> One (r442) + | 505 -> One (r443) + | 507 | 1970 -> One (r444) + | 509 -> One (r445) + | 513 -> One (r446) + | 525 -> One (r447) + | 530 -> One (r448) + | 529 -> One (r449) + | 904 -> One (r450) + | 1125 -> One (r452) + | 1124 -> One (r453) + | 1121 -> One (r454) + | 1118 -> One (r455) + | 539 -> One (r456) + | 1117 -> One (r457) + | 1052 -> One (r458) + | 1051 -> One (r459) + | 1050 -> One (r460) + | 1055 -> One (r462) + | 1112 -> One (r464) + | 1111 -> One (r465) + | 1110 -> One (r466) + | 1109 -> One (r467) + | 1108 -> One (r468) + | 1102 -> One (r469) + | 547 -> One (r470) + | 546 -> One (r471) + | 1099 -> One (r472) + | 550 -> One (r473) + | 549 -> One (r474) + | 1092 -> One (r475) + | 1081 -> One (r476) + | 1080 -> One (r477) + | 553 -> One (r478) + | 552 -> One (r479) + | 1079 -> One (r480) + | 556 -> One (r481) + | 555 -> One (r482) + | 1078 -> One (r483) + | 1074 -> One (r484) + | 1073 -> One (r485) + | 1072 -> One (r486) + | 580 -> One (r487) + | 582 -> One (r489) + | 864 -> One (r491) + | 581 -> One (r493) + | 862 -> One (r495) + | 1071 -> One (r497) + | 588 -> One (r498) + | 587 -> One (r499) + | 584 -> One (r500) + | 562 -> One (r501) + | 561 -> One (r502) + | 564 -> One (r503) + | 573 -> One (r505) + | 571 -> One (r506) + | 570 -> One (r507) + | 569 -> One (r508) + | 568 -> One (r509) + | 577 -> One (r510) + | 576 -> One (r511) + | 579 -> One (r512) + | 586 -> One (r513) + | 592 -> One (r514) + | 591 -> One (r515) + | 590 -> One (r516) + | 1070 -> One (r517) + | 597 -> One (r518) + | 596 -> One (r519) + | 595 -> One (r520) + | 599 -> One (r521) + | 1064 -> One (r522) + | 1069 -> One (r524) + | 1068 -> One (r525) + | 1067 -> One (r526) + | 1066 -> One (r527) + | 1065 -> One (r528) + | 1062 -> One (r529) + | 605 -> One (r530) + | 604 -> One (r531) + | 603 -> One (r532) + | 602 -> One (r533) + | 609 -> One (r534) + | 614 -> One (r535) + | 613 -> One (r536) + | 612 | 1059 -> One (r537) + | 1058 -> One (r538) + | 623 -> One (r539) + | 622 -> One (r540) + | 621 -> One (r541) + | 620 -> One (r542) + | 619 -> One (r543) + | 618 -> One (r544) + | 1022 -> One (r545) + | 630 -> One (r546) + | 629 -> One (r547) + | 634 -> One (r548) + | 633 -> One (r549) + | 632 -> One (r550) + | 636 -> One (r551) + | 919 | 1015 -> One (r552) + | 918 | 1014 -> One (r553) + | 638 | 917 -> One (r554) + | 637 | 916 -> One (r555) + | 642 -> One (r556) + | 641 -> One (r557) | 640 -> One (r558) - | 644 | 1413 -> One (r559) - | 643 | 1412 -> One (r560) - | 642 | 1411 -> One (r561) - | 641 | 1410 -> One (r562) - | 1372 -> One (r563) - | 655 -> One (r564) - | 654 -> One (r565) - | 659 -> One (r566) - | 658 -> One (r567) - | 662 -> One (r568) - | 664 -> One (r569) - | 669 -> One (r570) - | 673 -> One (r571) - | 672 -> One (r572) - | 676 -> One (r573) - | 678 -> One (r574) - | 680 -> One (r575) - | 682 -> One (r576) - | 684 -> One (r577) - | 686 -> One (r578) - | 688 -> One (r579) - | 690 -> One (r580) - | 692 -> One (r581) - | 694 -> One (r582) - | 696 -> One (r583) - | 698 -> One (r584) - | 700 -> One (r585) - | 702 -> One (r586) - | 704 -> One (r587) - | 706 -> One (r588) - | 708 -> One (r589) - | 710 -> One (r590) - | 712 -> One (r591) - | 714 -> One (r592) - | 1371 -> One (r593) - | 739 -> One (r594) - | 716 -> One (r595) - | 721 -> One (r596) - | 720 -> One (r597) - | 719 -> One (r598) - | 724 -> One (r599) - | 723 -> One (r600) - | 726 -> One (r601) - | 728 -> One (r602) - | 730 -> One (r603) - | 732 -> One (r604) - | 737 -> One (r605) - | 1370 -> One (r606) - | 1369 -> One (r607) - | 741 -> One (r608) - | 743 -> One (r609) - | 745 -> One (r610) - | 762 -> One (r611) - | 761 -> One (r612) - | 780 -> One (r614) - | 779 -> One (r615) - | 778 -> One (r616) - | 758 -> One (r617) - | 757 -> One (r618) - | 756 -> One (r619) - | 753 -> One (r620) - | 750 -> One (r621) - | 749 -> One (r622) - | 748 -> One (r623) - | 747 -> One (r624) - | 752 -> One (r625) - | 755 -> One (r626) - | 777 -> One (r627) - | 768 -> One (r628) - | 767 -> One (r629) - | 760 -> One (r630) - | 766 -> One (r631) - | 765 -> One (r632) - | 764 -> One (r633) - | 774 -> One (r634) - | 773 -> One (r635) - | 772 -> One (r636) - | 771 -> One (r637) - | 770 -> One (r638) - | 776 -> One (r639) - | 1368 -> One (r640) - | 1367 -> One (r641) - | 782 -> One (r642) - | 1363 -> One (r643) - | 1362 -> One (r644) + | 1012 -> One (r559) + | 648 -> One (r560) + | 647 -> One (r561) + | 646 -> One (r562) + | 661 -> One (r563) + | 656 -> One (r564) + | 655 | 840 -> One (r565) + | 660 -> One (r567) + | 659 -> One (r568) + | 652 -> One (r569) + | 654 -> One (r570) + | 658 -> One (r571) + | 663 -> One (r572) + | 665 -> One (r573) + | 667 -> One (r574) + | 671 | 947 -> One (r575) + | 670 | 946 -> One (r576) + | 669 | 945 -> One (r577) + | 668 | 944 -> One (r578) + | 892 -> One (r579) + | 677 -> One (r580) + | 676 -> One (r581) + | 675 -> One (r582) + | 686 -> One (r583) + | 685 -> One (r584) + | 694 -> One (r585) + | 693 -> One (r586) + | 692 -> One (r587) + | 691 -> One (r588) + | 700 -> One (r589) + | 699 -> One (r590) + | 698 -> One (r591) + | 697 -> One (r592) + | 709 -> One (r593) + | 708 -> One (r594) + | 707 -> One (r595) + | 706 -> One (r596) + | 713 -> One (r597) + | 712 -> One (r598) + | 720 -> One (r599) + | 719 -> One (r600) + | 718 -> One (r601) + | 717 -> One (r602) + | 726 -> One (r603) + | 725 -> One (r604) + | 724 -> One (r605) + | 723 -> One (r606) + | 732 -> One (r607) + | 731 -> One (r608) + | 730 -> One (r609) + | 729 -> One (r610) + | 738 -> One (r611) + | 737 -> One (r612) + | 736 -> One (r613) + | 735 -> One (r614) + | 744 -> One (r615) + | 743 -> One (r616) + | 742 -> One (r617) + | 741 -> One (r618) + | 750 -> One (r619) + | 749 -> One (r620) + | 748 -> One (r621) + | 747 -> One (r622) + | 756 -> One (r623) + | 755 -> One (r624) + | 754 -> One (r625) + | 753 -> One (r626) + | 762 -> One (r627) + | 761 -> One (r628) + | 760 -> One (r629) + | 759 -> One (r630) + | 768 -> One (r631) + | 767 -> One (r632) + | 766 -> One (r633) + | 765 -> One (r634) + | 774 -> One (r635) + | 773 -> One (r636) + | 772 -> One (r637) + | 771 -> One (r638) + | 780 -> One (r639) + | 779 -> One (r640) + | 778 -> One (r641) + | 777 -> One (r642) + | 786 -> One (r643) + | 785 -> One (r644) | 784 -> One (r645) - | 789 -> One (r646) - | 788 -> One (r647) - | 787 -> One (r648) - | 786 -> One (r649) - | 802 -> One (r650) - | 805 -> One (r652) - | 804 -> One (r653) - | 801 -> One (r654) - | 800 -> One (r655) - | 794 -> One (r656) - | 793 -> One (r657) - | 792 -> One (r658) - | 791 -> One (r659) - | 799 -> One (r660) - | 798 -> One (r661) - | 797 -> One (r662) - | 847 -> One (r664) - | 846 -> One (r665) - | 845 -> One (r666) - | 840 -> One (r667) - | 861 -> One (r671) - | 860 -> One (r672) - | 859 -> One (r673) - | 987 -> One (r674) - | 986 -> One (r675) - | 985 -> One (r676) - | 984 -> One (r677) - | 839 -> One (r678) - | 838 -> One (r680) - | 834 -> One (r687) - | 831 -> One (r689) - | 830 -> One (r690) - | 828 -> One (r691) - | 827 -> One (r692) - | 826 -> One (r693) - | 825 -> One (r694) - | 821 -> One (r695) - | 820 -> One (r696) - | 824 -> One (r697) - | 823 -> One (r698) - | 837 -> One (r699) - | 836 -> One (r700) - | 844 -> One (r701) - | 858 -> One (r702) - | 854 -> One (r703) - | 850 -> One (r704) - | 853 -> One (r705) - | 852 -> One (r706) - | 857 -> One (r707) - | 856 -> One (r708) - | 1149 -> One (r709) - | 915 -> One (r710) - | 930 -> One (r712) - | 929 -> One (r713) - | 928 -> One (r714) - | 927 -> One (r715) - | 926 -> One (r716) - | 913 -> One (r720) - | 912 -> One (r721) - | 911 -> One (r722) - | 909 -> One (r723) - | 908 -> One (r724) - | 885 -> One (r726) - | 884 -> One (r727) - | 883 -> One (r728) - | 874 -> One (r729) - | 873 -> One (r730) - | 879 -> One (r731) - | 878 -> One (r732) - | 877 | 1694 -> One (r733) - | 881 | 1693 -> One (r734) - | 902 -> One (r735) - | 894 -> One (r736) - | 893 -> One (r737) - | 892 -> One (r738) - | 901 -> One (r739) - | 900 -> One (r740) - | 922 -> One (r741) - | 921 -> One (r742) - | 920 -> One (r743) - | 1148 -> One (r744) - | 941 -> One (r745) - | 940 -> One (r746) - | 939 -> One (r747) - | 938 -> One (r748) - | 937 -> One (r749) - | 936 -> One (r750) - | 935 -> One (r751) - | 934 -> One (r752) - | 974 -> One (r753) - | 973 -> One (r754) - | 976 -> One (r756) - | 975 -> One (r757) - | 969 -> One (r758) - | 951 -> One (r759) - | 950 -> One (r760) - | 949 -> One (r761) - | 948 -> One (r762) - | 947 -> One (r763) - | 955 -> One (r767) - | 954 -> One (r768) - | 968 -> One (r769) - | 960 -> One (r770) - | 959 -> One (r771) - | 958 -> One (r772) - | 957 -> One (r773) - | 967 -> One (r774) - | 966 -> One (r775) - | 965 -> One (r776) - | 964 -> One (r777) - | 963 -> One (r778) - | 962 -> One (r779) - | 972 -> One (r782) - | 971 -> One (r783) - | 978 -> One (r784) - | 983 -> One (r785) - | 982 -> One (r786) - | 981 -> One (r787) - | 980 -> One (r788) - | 1043 | 1097 -> One (r790) - | 1099 -> One (r792) - | 1113 -> One (r794) - | 1103 -> One (r795) - | 1102 -> One (r796) - | 1084 -> One (r797) - | 1083 -> One (r798) - | 1082 -> One (r799) - | 1081 -> One (r800) - | 1080 -> One (r801) - | 1079 -> One (r802) - | 1078 -> One (r803) - | 1068 -> One (r804) - | 1067 -> One (r805) - | 999 -> One (r806) - | 998 -> One (r807) - | 997 -> One (r808) - | 993 -> One (r809) - | 991 -> One (r810) - | 990 -> One (r811) - | 996 -> One (r812) - | 995 -> One (r813) - | 1061 -> One (r814) - | 1060 -> One (r815) - | 1005 -> One (r816) - | 1001 -> One (r817) - | 1004 -> One (r818) - | 1003 -> One (r819) - | 1016 -> One (r820) - | 1015 -> One (r821) - | 1014 -> One (r822) - | 1013 -> One (r823) - | 1012 -> One (r824) - | 1007 -> One (r825) - | 1027 -> One (r826) - | 1026 -> One (r827) - | 1025 -> One (r828) - | 1024 -> One (r829) - | 1023 -> One (r830) - | 1018 -> One (r831) - | 1052 -> One (r832) - | 1051 -> One (r833) - | 1029 -> One (r834) - | 1050 -> One (r835) - | 1049 -> One (r836) - | 1048 -> One (r837) - | 1047 -> One (r838) - | 1031 -> One (r839) - | 1045 -> One (r840) - | 1035 -> One (r841) - | 1034 -> One (r842) - | 1033 -> One (r843) - | 1042 | 1090 -> One (r844) - | 1039 -> One (r846) - | 1038 -> One (r847) - | 1037 -> One (r848) - | 1036 | 1089 -> One (r849) - | 1041 -> One (r850) - | 1057 -> One (r851) - | 1056 -> One (r852) - | 1055 -> One (r853) - | 1059 -> One (r855) - | 1058 -> One (r856) - | 1054 -> One (r857) - | 1063 -> One (r858) - | 1066 -> One (r859) - | 1077 -> One (r860) - | 1076 -> One (r861) - | 1075 -> One (r862) - | 1074 -> One (r863) - | 1073 -> One (r864) - | 1072 -> One (r865) - | 1071 -> One (r866) - | 1070 -> One (r867) - | 1101 -> One (r868) - | 1088 -> One (r869) - | 1087 -> One (r870) - | 1086 -> One (r871) - | 1100 -> One (r872) - | 1092 -> One (r873) - | 1098 -> One (r874) - | 1095 -> One (r875) - | 1094 -> One (r876) - | 1112 -> One (r877) - | 1111 -> One (r878) - | 1110 -> One (r879) - | 1109 -> One (r880) - | 1108 -> One (r881) - | 1107 -> One (r882) - | 1106 -> One (r883) - | 1105 -> One (r884) - | 1122 -> One (r885) - | 1124 -> One (r886) - | 1134 -> One (r887) - | 1133 -> One (r888) - | 1132 -> One (r889) - | 1131 -> One (r890) - | 1130 -> One (r891) - | 1129 -> One (r892) - | 1128 -> One (r893) - | 1127 -> One (r894) - | 1145 -> One (r895) - | 1144 -> One (r896) - | 1143 -> One (r897) - | 1142 -> One (r898) - | 1141 -> One (r899) - | 1140 -> One (r900) - | 1139 -> One (r901) - | 1138 -> One (r902) - | 1137 -> One (r903) - | 1267 -> One (r904) - | 1316 -> One (r906) - | 1158 -> One (r907) - | 1333 -> One (r909) - | 1324 -> One (r910) - | 1323 -> One (r911) - | 1157 -> One (r912) - | 1156 -> One (r913) - | 1155 -> One (r914) - | 1154 -> One (r915) - | 1153 -> One (r916) - | 1310 -> One (r917) - | 1309 -> One (r918) - | 1161 -> One (r919) - | 1160 -> One (r920) - | 1186 -> One (r921) - | 1185 -> One (r922) - | 1184 -> One (r923) - | 1183 -> One (r924) - | 1174 -> One (r925) - | 1173 -> One (r927) - | 1172 -> One (r928) - | 1168 -> One (r929) - | 1167 -> One (r930) - | 1166 -> One (r931) - | 1165 -> One (r932) - | 1164 -> One (r933) - | 1171 -> One (r934) - | 1170 -> One (r935) - | 1182 -> One (r936) - | 1181 -> One (r937) - | 1180 -> One (r938) - | 1189 -> One (r939) - | 1188 -> One (r940) - | 1236 -> One (r941) - | 1225 -> One (r942) - | 1224 -> One (r943) - | 1215 -> One (r944) - | 1214 -> One (r946) - | 1213 -> One (r947) - | 1205 -> One (r948) - | 1194 -> One (r949) - | 1193 -> One (r950) - | 1192 -> One (r951) - | 1204 -> One (r952) - | 1203 -> One (r953) - | 1202 -> One (r954) - | 1201 -> One (r955) - | 1200 -> One (r956) - | 1199 -> One (r957) - | 1198 -> One (r958) - | 1197 -> One (r959) - | 1212 -> One (r960) - | 1210 -> One (r961) - | 1209 -> One (r962) - | 1223 -> One (r963) - | 1222 -> One (r964) - | 1221 -> One (r965) - | 1235 -> One (r966) - | 1234 -> One (r967) - | 1233 -> One (r968) - | 1232 -> One (r969) - | 1231 -> One (r970) - | 1230 -> One (r971) - | 1229 -> One (r972) - | 1228 -> One (r973) - | 1240 -> One (r974) - | 1239 -> One (r975) - | 1238 -> One (r976) - | 1304 -> One (r977) - | 1303 -> One (r978) - | 1302 -> One (r979) - | 1301 -> One (r980) - | 1300 -> One (r981) - | 1299 -> One (r982) - | 1296 -> One (r983) - | 1243 -> One (r984) - | 1292 -> One (r985) - | 1291 -> One (r986) - | 1286 -> One (r987) - | 1285 -> One (r988) - | 1284 -> One (r989) - | 1283 -> One (r990) - | 1252 -> One (r991) - | 1251 -> One (r992) - | 1250 -> One (r993) - | 1249 -> One (r994) - | 1248 -> One (r995) - | 1247 -> One (r996) - | 1282 -> One (r997) - | 1256 -> One (r998) - | 1255 -> One (r999) - | 1254 -> One (r1000) - | 1260 -> One (r1001) - | 1259 -> One (r1002) - | 1258 -> One (r1003) - | 1279 -> One (r1004) - | 1264 -> One (r1005) - | 1263 -> One (r1006) - | 1281 -> One (r1008) - | 1262 -> One (r1009) - | 1276 -> One (r1010) - | 1266 -> One (r1011) - | 1270 -> One (r1012) - | 1290 -> One (r1013) - | 1289 -> One (r1014) - | 1288 -> One (r1015) - | 1295 -> One (r1016) - | 1294 -> One (r1017) - | 1298 -> One (r1018) - | 1308 -> One (r1019) - | 1307 -> One (r1020) - | 1306 -> One (r1021) - | 1312 -> One (r1022) - | 1315 -> One (r1023) - | 1320 -> One (r1024) - | 1319 -> One (r1025) - | 1318 -> One (r1026) - | 1322 -> One (r1027) - | 1332 -> One (r1028) - | 1331 -> One (r1029) - | 1330 -> One (r1030) - | 1329 -> One (r1031) - | 1328 -> One (r1032) - | 1327 -> One (r1033) - | 1326 -> One (r1034) - | 1349 -> One (r1035) - | 1353 -> One (r1036) - | 1355 -> One (r1037) - | 1361 -> One (r1038) - | 1360 -> One (r1039) - | 1375 | 1418 -> One (r1040) - | 1374 | 1417 -> One (r1041) - | 1373 | 1416 -> One (r1042) - | 1378 | 1423 -> One (r1043) - | 1377 | 1422 -> One (r1044) - | 1376 | 1421 -> One (r1045) - | 1383 | 1430 -> One (r1046) - | 1382 | 1429 -> One (r1047) - | 1381 | 1428 -> One (r1048) - | 1380 | 1427 -> One (r1049) - | 1389 | 1435 -> One (r1050) - | 1388 | 1434 -> One (r1051) - | 1387 | 1433 -> One (r1052) - | 1392 | 1440 -> One (r1053) - | 1391 | 1439 -> One (r1054) - | 1390 | 1438 -> One (r1055) - | 1399 -> One (r1056) - | 1402 | 1452 -> One (r1057) - | 1401 | 1451 -> One (r1058) - | 1400 | 1450 -> One (r1059) - | 1404 -> One (r1060) - | 1407 | 1455 -> One (r1061) - | 1406 | 1454 -> One (r1062) - | 1405 | 1453 -> One (r1063) - | 1409 -> One (r1064) - | 1415 -> One (r1065) - | 1420 -> One (r1066) - | 1425 -> One (r1067) - | 1432 -> One (r1068) - | 1437 -> One (r1069) - | 1442 -> One (r1070) - | 1445 -> One (r1071) - | 1459 -> One (r1072) - | 1458 -> One (r1073) - | 1464 -> One (r1074) - | 1468 -> One (r1075) - | 1470 -> One (r1076) - | 1472 -> One (r1077) - | 1474 -> One (r1078) - | 1476 -> One (r1079) - | 1479 -> One (r1081) - | 1478 -> One (r1082) - | 1492 -> One (r1083) - | 1491 -> One (r1084) - | 1483 -> One (r1085) - | 1482 -> One (r1086) - | 1515 -> One (r1087) - | 1514 -> One (r1088) - | 1513 -> One (r1089) - | 1512 -> One (r1090) - | 1511 -> One (r1091) - | 1510 -> One (r1092) - | 1527 -> One (r1093) - | 1520 -> One (r1094) - | 1519 -> One (r1095) - | 1524 -> One (r1096) - | 1523 -> One (r1097) - | 1522 -> One (r1098) - | 1526 -> One (r1099) - | 1540 -> One (r1100) - | 1546 -> One (r1101) - | 1549 -> One (r1102) - | 1562 -> One (r1103) - | 1577 -> One (r1104) - | 1576 -> One (r1105) - | 1575 -> One (r1106) - | 1574 -> One (r1107) - | 1573 -> One (r1108) - | 1572 -> One (r1109) - | 1585 -> One (r1110) - | 1584 -> One (r1111) - | 1583 -> One (r1112) - | 1582 -> One (r1113) - | 1581 -> One (r1114) - | 1580 -> One (r1115) - | 1579 -> One (r1116) - | 1599 -> One (r1117) - | 1598 -> One (r1118) - | 1597 -> One (r1119) - | 1596 -> One (r1120) - | 1595 -> One (r1121) - | 1604 -> One (r1122) - | 1603 -> One (r1123) - | 1602 -> One (r1124) - | 1601 -> One (r1125) - | 1607 -> One (r1126) - | 1606 -> One (r1127) - | 1614 -> One (r1128) - | 1620 -> One (r1129) - | 1619 -> One (r1130) - | 1618 -> One (r1131) - | 1617 -> One (r1132) - | 1623 -> One (r1133) - | 1622 -> One (r1134) - | 1627 -> One (r1135) - | 1638 -> One (r1136) - | 1637 -> One (r1137) - | 1641 -> One (r1138) - | 1640 -> One (r1139) - | 1644 -> One (r1140) - | 1643 -> One (r1141) - | 1653 -> One (r1142) - | 1652 -> One (r1143) - | 1660 -> One (r1144) - | 1668 -> One (r1145) - | 1676 -> One (r1146) - | 1673 -> One (r1147) - | 1675 -> One (r1148) - | 1678 -> One (r1149) - | 1680 -> One (r1150) - | 1682 -> One (r1151) - | 1685 -> One (r1152) - | 1684 -> One (r1153) - | 1697 -> One (r1154) - | 1696 -> One (r1155) - | 1709 -> One (r1156) - | 1708 -> One (r1157) - | 1732 -> One (r1158) - | 1731 -> One (r1159) - | 1741 -> One (r1160) - | 1743 -> One (r1161) - | 1745 -> One (r1162) - | 1758 -> One (r1163) - | 1762 -> One (r1164) - | 1767 -> One (r1165) - | 1774 -> One (r1166) - | 1773 -> One (r1167) - | 1772 -> One (r1168) - | 1771 -> One (r1169) - | 1781 -> One (r1170) - | 1785 -> One (r1171) - | 1789 -> One (r1172) - | 1792 -> One (r1173) - | 1797 -> One (r1174) - | 1801 -> One (r1175) - | 1805 -> One (r1176) - | 1809 -> One (r1177) - | 1813 -> One (r1178) - | 1816 -> One (r1179) - | 1820 -> One (r1180) - | 1826 -> One (r1181) - | 1836 -> One (r1182) - | 1838 -> One (r1183) - | 1841 -> One (r1184) - | 1840 -> One (r1185) - | 1843 -> One (r1186) - | 1853 -> One (r1187) - | 1849 -> One (r1188) - | 1848 -> One (r1189) - | 1852 -> One (r1190) - | 1851 -> One (r1191) - | 1858 -> One (r1192) - | 1857 -> One (r1193) - | 1856 -> One (r1194) - | 1860 -> One (r1195) - | 363 -> Select (function - | -1 -> [R 107] - | _ -> S (T T_DOT) :: r328) - | 593 -> Select (function - | -1 -> [R 107] - | _ -> r528) - | 173 -> Select (function - | -1 -> r152 - | _ -> R 187 :: r144) - | 807 -> Select (function - | -1 -> r677 - | _ -> R 187 :: r670) - | 864 -> Select (function - | -1 -> r152 - | _ -> R 187 :: r719) - | 943 -> Select (function - | -1 -> r624 - | _ -> R 187 :: r766) - | 506 -> Select (function - | -1 -> r278 - | _ -> [R 221]) - | 381 -> Select (function - | -1 -> [R 673] - | _ -> S (N N_pattern) :: r336) - | 378 -> Select (function - | -1 -> [R 674] - | _ -> S (N N_pattern) :: r335) - | 179 -> Select (function - | -1 -> r164 - | _ -> R 781 :: r158) - | 867 -> Select (function - | -1 -> r164 - | _ -> R 781 :: r725) - | 841 -> Select (function - | -1 -> S (T T_RPAREN) :: r54 - | _ -> S (T T_COLONCOLON) :: r344) - | 87 -> Select (function - | 252 | 442 | 608 | 716 | 1249 | 1288 | 1339 | 1463 -> r61 - | -1 -> S (T T_RPAREN) :: r54 - | _ -> S (N N_pattern) :: r56) - | 243 -> Select (function - | -1 -> S (T T_RPAREN) :: r54 - | _ -> Sub (r1) :: r232) - | 254 -> Select (function - | -1 -> S (T T_RBRACKET) :: r243 - | _ -> Sub (r245) :: r247) - | 547 -> Select (function - | -1 -> S (T T_RBRACKET) :: r243 - | _ -> Sub (r456) :: r458) - | 462 -> Select (function - | 60 | 172 | 210 | 741 | 782 | 784 -> r401 - | _ -> S (T T_OPEN) :: r395) - | 843 -> Select (function - | -1 -> r449 - | _ -> S (T T_LPAREN) :: r701) - | 270 -> Select (function - | -1 -> r280 - | _ -> S (T T_DOT) :: r282) - | 504 -> Select (function - | -1 -> r280 - | _ -> S (T T_DOT) :: r444) - | 203 -> Select (function - | -1 -> r123 - | _ -> S (T T_COLON) :: r185) - | 152 -> Select (function - | 848 | 1593 -> r107 - | _ -> Sub (r105) :: r108) - | 155 -> Select (function - | 848 | 1593 -> r106 - | _ -> r108) - | 1711 -> Select (function - | -1 -> r148 - | _ -> r123) - | 198 -> Select (function - | -1 -> r162 - | _ -> r123) - | 918 -> Select (function - | -1 -> r148 - | _ -> r123) - | 869 -> Select (function - | -1 -> r162 - | _ -> r123) - | 1710 -> Select (function - | -1 -> r149 - | _ -> r142) + | 783 -> One (r646) + | 792 -> One (r647) + | 791 -> One (r648) + | 790 -> One (r649) + | 789 -> One (r650) + | 798 -> One (r651) + | 797 -> One (r652) + | 796 -> One (r653) + | 795 -> One (r654) + | 804 -> One (r655) + | 803 -> One (r656) + | 802 -> One (r657) + | 801 -> One (r658) + | 810 -> One (r659) + | 809 -> One (r660) + | 808 -> One (r661) + | 807 -> One (r662) + | 816 -> One (r663) + | 815 -> One (r664) + | 814 -> One (r665) + | 813 -> One (r666) + | 822 -> One (r667) + | 821 -> One (r668) + | 820 -> One (r669) + | 819 -> One (r670) + | 828 -> One (r671) + | 827 -> One (r672) + | 826 -> One (r673) + | 825 -> One (r674) + | 834 -> One (r675) + | 833 -> One (r676) + | 832 -> One (r677) + | 831 -> One (r678) + | 890 -> One (r679) + | 887 -> One (r680) + | 836 -> One (r681) + | 839 -> One (r682) + | 838 -> One (r683) + | 846 -> One (r684) + | 845 -> One (r685) + | 844 -> One (r686) + | 843 -> One (r687) + | 842 -> One (r688) + | 853 -> One (r689) + | 852 -> One (r690) + | 851 -> One (r691) + | 850 -> One (r692) + | 849 -> One (r693) + | 856 -> One (r694) + | 855 -> One (r695) + | 863 -> One (r696) + | 861 -> One (r697) + | 860 -> One (r698) + | 869 -> One (r699) + | 868 -> One (r700) + | 867 -> One (r701) + | 872 -> One (r702) + | 871 -> One (r703) + | 874 -> One (r704) + | 876 -> One (r705) + | 878 -> One (r706) + | 880 -> One (r707) + | 885 -> One (r708) + | 889 -> One (r709) + | 895 | 956 -> One (r710) + | 894 | 955 -> One (r711) + | 893 | 954 -> One (r712) + | 898 | 965 -> One (r713) + | 897 | 964 -> One (r714) + | 896 | 963 -> One (r715) + | 903 | 976 -> One (r716) + | 902 | 975 -> One (r717) + | 901 | 974 -> One (r718) + | 900 | 973 -> One (r719) + | 909 | 985 -> One (r720) + | 908 | 984 -> One (r721) + | 907 | 983 -> One (r722) + | 912 | 994 -> One (r723) + | 911 | 993 -> One (r724) + | 910 | 992 -> One (r725) + | 915 -> One (r726) + | 925 -> One (r727) + | 924 -> One (r728) + | 923 -> One (r729) + | 922 -> One (r730) + | 928 | 1018 -> One (r731) + | 927 | 1017 -> One (r732) + | 926 | 1016 -> One (r733) + | 934 -> One (r734) + | 933 -> One (r735) + | 932 -> One (r736) + | 931 -> One (r737) + | 937 | 1021 -> One (r738) + | 936 | 1020 -> One (r739) + | 935 | 1019 -> One (r740) + | 943 -> One (r741) + | 942 -> One (r742) + | 941 -> One (r743) + | 940 -> One (r744) + | 953 -> One (r745) + | 952 -> One (r746) + | 951 -> One (r747) + | 950 -> One (r748) + | 962 -> One (r749) + | 961 -> One (r750) + | 960 -> One (r751) + | 959 -> One (r752) + | 971 -> One (r753) + | 970 -> One (r754) + | 969 -> One (r755) + | 968 -> One (r756) + | 982 -> One (r757) + | 981 -> One (r758) + | 980 -> One (r759) + | 979 -> One (r760) + | 991 -> One (r761) + | 990 -> One (r762) + | 989 -> One (r763) + | 988 -> One (r764) + | 1000 -> One (r765) + | 999 -> One (r766) + | 998 -> One (r767) + | 997 -> One (r768) + | 1007 -> One (r769) + | 1006 -> One (r770) + | 1005 -> One (r771) + | 1004 -> One (r772) + | 1025 -> One (r773) + | 1024 -> One (r774) + | 1030 -> One (r775) + | 1034 -> One (r776) + | 1036 -> One (r777) + | 1038 -> One (r778) + | 1040 -> One (r779) + | 1042 -> One (r780) + | 1045 -> One (r782) + | 1044 -> One (r783) + | 1057 -> One (r784) + | 1056 -> One (r785) + | 1049 -> One (r786) + | 1048 -> One (r787) + | 1085 -> One (r788) + | 1084 -> One (r789) + | 1083 -> One (r790) + | 1091 -> One (r791) + | 1090 -> One (r792) + | 1089 -> One (r793) + | 1088 -> One (r794) + | 1098 -> One (r795) + | 1097 -> One (r796) + | 1096 -> One (r797) + | 1095 -> One (r798) + | 1101 -> One (r799) + | 1107 -> One (r800) + | 1106 -> One (r801) + | 1105 -> One (r802) + | 1104 -> One (r803) + | 1116 -> One (r804) + | 1115 -> One (r805) + | 1114 -> One (r806) + | 1123 -> One (r807) + | 1137 -> One (r808) + | 1136 -> One (r809) + | 1144 -> One (r811) + | 1143 -> One (r812) + | 1142 -> One (r813) + | 1135 -> One (r814) + | 1134 -> One (r815) + | 1133 -> One (r816) + | 1141 -> One (r817) + | 1140 -> One (r818) + | 1139 -> One (r819) + | 1146 -> One (r820) + | 1194 -> One (r821) + | 1193 -> One (r822) + | 1192 -> One (r823) + | 1191 -> One (r824) + | 1155 -> One (r825) + | 1149 -> One (r826) + | 1148 -> One (r827) + | 1179 -> One (r828) + | 1178 -> One (r830) + | 1174 -> One (r837) + | 1171 -> One (r839) + | 1170 -> One (r840) + | 1168 -> One (r841) + | 1167 -> One (r842) + | 1166 -> One (r843) + | 1165 -> One (r844) + | 1161 -> One (r845) + | 1160 -> One (r846) + | 1164 -> One (r847) + | 1163 -> One (r848) + | 1177 -> One (r849) + | 1176 -> One (r850) + | 1190 -> One (r851) + | 1186 -> One (r852) + | 1182 -> One (r853) + | 1185 -> One (r854) + | 1184 -> One (r855) + | 1189 -> One (r856) + | 1188 -> One (r857) + | 1210 -> One (r858) + | 1209 -> One (r859) + | 1208 -> One (r860) + | 1214 -> One (r861) + | 1220 -> One (r862) + | 1219 -> One (r863) + | 1218 -> One (r864) + | 1217 -> One (r865) + | 1223 -> One (r866) + | 1222 -> One (r867) + | 1227 -> One (r868) + | 1235 -> One (r869) + | 1234 -> One (r870) + | 1233 -> One (r871) + | 1232 -> One (r872) + | 1238 -> One (r873) + | 1237 -> One (r874) + | 1241 -> One (r875) + | 1240 -> One (r876) + | 1244 -> One (r877) + | 1243 -> One (r878) + | 1249 -> One (r879) + | 1248 -> One (r880) + | 1252 -> One (r881) + | 1251 -> One (r882) + | 1255 -> One (r883) + | 1254 -> One (r884) + | 1286 -> One (r885) + | 1285 -> One (r886) + | 1284 -> One (r887) + | 1272 -> One (r888) + | 1271 -> One (r889) + | 1270 -> One (r890) + | 1269 -> One (r891) + | 1266 -> One (r892) + | 1265 -> One (r893) + | 1264 -> One (r894) + | 1263 -> One (r895) + | 1268 -> One (r896) + | 1283 -> One (r897) + | 1276 -> One (r898) + | 1275 -> One (r899) + | 1274 -> One (r900) + | 1282 -> One (r901) + | 1281 -> One (r902) + | 1280 -> One (r903) + | 1279 -> One (r904) + | 1278 -> One (r905) + | 1780 -> One (r906) + | 1779 -> One (r907) + | 1288 -> One (r908) + | 1290 -> One (r909) + | 1292 -> One (r910) + | 1778 -> One (r911) + | 1777 -> One (r912) + | 1294 -> One (r913) + | 1299 -> One (r914) + | 1298 -> One (r915) + | 1297 -> One (r916) + | 1296 -> One (r917) + | 1310 -> One (r918) + | 1313 -> One (r920) + | 1312 -> One (r921) + | 1309 -> One (r922) + | 1308 -> One (r923) + | 1304 -> One (r924) + | 1303 -> One (r925) + | 1302 -> One (r926) + | 1301 -> One (r927) + | 1307 -> One (r928) + | 1306 -> One (r929) + | 1326 -> One (r931) + | 1325 -> One (r932) + | 1324 -> One (r933) + | 1319 -> One (r934) + | 1329 -> One (r938) + | 1328 -> One (r939) + | 1327 -> One (r940) + | 1387 -> One (r941) + | 1386 -> One (r942) + | 1385 -> One (r943) + | 1384 -> One (r944) + | 1323 -> One (r945) + | 1580 -> One (r946) + | 1579 -> One (r947) + | 1341 -> One (r948) + | 1340 -> One (r949) + | 1339 -> One (r950) + | 1338 -> One (r951) + | 1337 -> One (r952) + | 1336 -> One (r953) + | 1335 -> One (r954) + | 1334 -> One (r955) + | 1374 -> One (r956) + | 1373 -> One (r957) + | 1376 -> One (r959) + | 1375 -> One (r960) + | 1369 -> One (r961) + | 1351 -> One (r962) + | 1350 -> One (r963) + | 1349 -> One (r964) + | 1348 -> One (r965) + | 1347 -> One (r966) + | 1355 -> One (r970) + | 1354 -> One (r971) + | 1368 -> One (r972) + | 1360 -> One (r973) + | 1359 -> One (r974) + | 1358 -> One (r975) + | 1357 -> One (r976) + | 1367 -> One (r977) + | 1366 -> One (r978) + | 1365 -> One (r979) + | 1364 -> One (r980) + | 1363 -> One (r981) + | 1362 -> One (r982) + | 1372 -> One (r985) + | 1371 -> One (r986) + | 1378 -> One (r987) + | 1383 -> One (r988) + | 1382 -> One (r989) + | 1381 -> One (r990) + | 1380 -> One (r991) + | 1443 | 1497 -> One (r993) + | 1499 -> One (r995) + | 1513 -> One (r997) + | 1503 -> One (r998) + | 1502 -> One (r999) + | 1484 -> One (r1000) + | 1483 -> One (r1001) + | 1482 -> One (r1002) + | 1481 -> One (r1003) + | 1480 -> One (r1004) + | 1479 -> One (r1005) + | 1478 -> One (r1006) + | 1468 -> One (r1007) + | 1467 -> One (r1008) + | 1399 -> One (r1009) + | 1398 -> One (r1010) + | 1397 -> One (r1011) + | 1393 -> One (r1012) + | 1391 -> One (r1013) + | 1390 -> One (r1014) + | 1396 -> One (r1015) + | 1395 -> One (r1016) + | 1461 -> One (r1017) + | 1460 -> One (r1018) + | 1405 -> One (r1019) + | 1401 -> One (r1020) + | 1404 -> One (r1021) + | 1403 -> One (r1022) + | 1416 -> One (r1023) + | 1415 -> One (r1024) + | 1414 -> One (r1025) + | 1413 -> One (r1026) + | 1412 -> One (r1027) + | 1407 -> One (r1028) + | 1427 -> One (r1029) + | 1426 -> One (r1030) + | 1425 -> One (r1031) + | 1424 -> One (r1032) + | 1423 -> One (r1033) + | 1418 -> One (r1034) + | 1452 -> One (r1035) + | 1451 -> One (r1036) + | 1429 -> One (r1037) + | 1450 -> One (r1038) + | 1449 -> One (r1039) + | 1448 -> One (r1040) + | 1447 -> One (r1041) + | 1431 -> One (r1042) + | 1445 -> One (r1043) + | 1435 -> One (r1044) + | 1434 -> One (r1045) + | 1433 -> One (r1046) + | 1442 | 1490 -> One (r1047) + | 1439 -> One (r1049) + | 1438 -> One (r1050) + | 1437 -> One (r1051) + | 1436 | 1489 -> One (r1052) + | 1441 -> One (r1053) + | 1457 -> One (r1054) + | 1456 -> One (r1055) + | 1455 -> One (r1056) + | 1459 -> One (r1058) + | 1458 -> One (r1059) + | 1454 -> One (r1060) + | 1463 -> One (r1061) + | 1466 -> One (r1062) + | 1477 -> One (r1063) + | 1476 -> One (r1064) + | 1475 -> One (r1065) + | 1474 -> One (r1066) + | 1473 -> One (r1067) + | 1472 -> One (r1068) + | 1471 -> One (r1069) + | 1470 -> One (r1070) + | 1501 -> One (r1071) + | 1488 -> One (r1072) + | 1487 -> One (r1073) + | 1486 -> One (r1074) + | 1500 -> One (r1075) + | 1492 -> One (r1076) + | 1498 -> One (r1077) + | 1495 -> One (r1078) + | 1494 -> One (r1079) + | 1512 -> One (r1080) + | 1511 -> One (r1081) + | 1510 -> One (r1082) + | 1509 -> One (r1083) + | 1508 -> One (r1084) + | 1507 -> One (r1085) + | 1506 -> One (r1086) + | 1505 -> One (r1087) + | 1522 -> One (r1088) + | 1524 -> One (r1089) + | 1534 -> One (r1090) + | 1533 -> One (r1091) + | 1532 -> One (r1092) + | 1531 -> One (r1093) + | 1530 -> One (r1094) + | 1529 -> One (r1095) + | 1528 -> One (r1096) + | 1527 -> One (r1097) + | 1576 -> One (r1098) + | 1556 -> One (r1099) + | 1555 -> One (r1100) + | 1554 -> One (r1101) + | 1553 -> One (r1102) + | 1540 -> One (r1103) + | 1539 -> One (r1104) + | 1538 -> One (r1105) + | 1537 -> One (r1106) + | 1544 -> One (r1107) + | 1543 -> One (r1108) + | 1549 -> One (r1109) + | 1548 -> One (r1110) + | 1547 | 1808 -> One (r1111) + | 1551 | 1807 -> One (r1112) + | 1573 -> One (r1113) + | 1565 -> One (r1114) + | 1564 -> One (r1115) + | 1563 -> One (r1116) + | 1572 -> One (r1117) + | 1571 -> One (r1118) + | 1692 -> One (r1119) + | 1736 -> One (r1121) + | 1589 -> One (r1122) + | 1753 -> One (r1124) + | 1744 -> One (r1125) + | 1743 -> One (r1126) + | 1588 -> One (r1127) + | 1587 -> One (r1128) + | 1586 -> One (r1129) + | 1585 -> One (r1130) + | 1584 -> One (r1131) + | 1730 -> One (r1132) + | 1729 -> One (r1133) + | 1592 -> One (r1134) + | 1591 -> One (r1135) + | 1617 -> One (r1136) + | 1616 -> One (r1137) + | 1615 -> One (r1138) + | 1614 -> One (r1139) + | 1605 -> One (r1140) + | 1604 -> One (r1142) + | 1603 -> One (r1143) + | 1599 -> One (r1144) + | 1598 -> One (r1145) + | 1597 -> One (r1146) + | 1596 -> One (r1147) + | 1595 -> One (r1148) + | 1602 -> One (r1149) + | 1601 -> One (r1150) + | 1613 -> One (r1151) + | 1612 -> One (r1152) + | 1611 -> One (r1153) + | 1620 -> One (r1154) + | 1619 -> One (r1155) + | 1661 -> One (r1157) + | 1650 -> One (r1158) + | 1649 -> One (r1159) + | 1640 -> One (r1160) + | 1639 -> One (r1162) + | 1638 -> One (r1163) + | 1637 -> One (r1164) + | 1626 -> One (r1165) + | 1625 -> One (r1166) + | 1623 -> One (r1167) + | 1636 -> One (r1168) + | 1635 -> One (r1169) + | 1634 -> One (r1170) + | 1633 -> One (r1171) + | 1632 -> One (r1172) + | 1631 -> One (r1173) + | 1630 -> One (r1174) + | 1629 -> One (r1175) + | 1648 -> One (r1176) + | 1647 -> One (r1177) + | 1646 -> One (r1178) + | 1660 -> One (r1179) + | 1659 -> One (r1180) + | 1658 -> One (r1181) + | 1657 -> One (r1182) + | 1656 -> One (r1183) + | 1655 -> One (r1184) + | 1654 -> One (r1185) + | 1653 -> One (r1186) + | 1665 -> One (r1187) + | 1664 -> One (r1188) + | 1663 -> One (r1189) + | 1724 -> One (r1190) + | 1723 -> One (r1191) + | 1722 -> One (r1192) + | 1721 -> One (r1193) + | 1720 -> One (r1194) + | 1719 -> One (r1195) + | 1716 -> One (r1196) + | 1668 -> One (r1197) + | 1712 -> One (r1198) + | 1711 -> One (r1199) + | 1706 -> One (r1200) + | 1705 -> One (r1201) + | 1704 -> One (r1202) + | 1703 -> One (r1203) + | 1677 -> One (r1204) + | 1676 -> One (r1205) + | 1675 -> One (r1206) + | 1674 -> One (r1207) + | 1673 -> One (r1208) + | 1672 -> One (r1209) + | 1702 -> One (r1210) + | 1681 -> One (r1211) + | 1680 -> One (r1212) + | 1679 -> One (r1213) + | 1685 -> One (r1214) + | 1684 -> One (r1215) + | 1683 -> One (r1216) + | 1699 -> One (r1217) + | 1689 -> One (r1218) + | 1688 -> One (r1219) + | 1701 -> One (r1221) + | 1687 -> One (r1222) + | 1696 -> One (r1223) + | 1691 -> One (r1224) + | 1710 -> One (r1225) + | 1709 -> One (r1226) + | 1708 -> One (r1227) + | 1715 -> One (r1228) + | 1714 -> One (r1229) + | 1718 -> One (r1230) + | 1728 -> One (r1231) + | 1727 -> One (r1232) + | 1726 -> One (r1233) + | 1732 -> One (r1234) + | 1735 -> One (r1235) + | 1740 -> One (r1236) + | 1739 -> One (r1237) + | 1738 -> One (r1238) + | 1742 -> One (r1239) + | 1752 -> One (r1240) + | 1751 -> One (r1241) + | 1750 -> One (r1242) + | 1749 -> One (r1243) + | 1748 -> One (r1244) + | 1747 -> One (r1245) + | 1746 -> One (r1246) + | 1762 -> One (r1247) + | 1765 -> One (r1248) + | 1767 -> One (r1249) + | 1773 -> One (r1250) + | 1772 -> One (r1251) + | 1783 -> One (r1252) + | 1782 -> One (r1253) + | 1794 -> One (r1254) + | 1793 -> One (r1255) + | 1811 -> One (r1256) + | 1810 -> One (r1257) + | 1823 -> One (r1258) + | 1822 -> One (r1259) + | 1839 -> One (r1260) + | 1847 -> One (r1261) + | 1855 -> One (r1262) + | 1852 -> One (r1263) + | 1854 -> One (r1264) + | 1857 -> One (r1265) + | 1860 -> One (r1266) + | 1863 -> One (r1267) + | 1862 -> One (r1268) + | 1871 -> One (r1269) + | 1870 -> One (r1270) + | 1869 -> One (r1271) + | 1885 -> One (r1272) + | 1884 -> One (r1273) + | 1883 -> One (r1274) + | 1905 -> One (r1275) + | 1909 -> One (r1276) + | 1914 -> One (r1277) + | 1921 -> One (r1278) + | 1920 -> One (r1279) + | 1919 -> One (r1280) + | 1918 -> One (r1281) + | 1928 -> One (r1282) + | 1932 -> One (r1283) + | 1936 -> One (r1284) + | 1939 -> One (r1285) + | 1944 -> One (r1286) + | 1948 -> One (r1287) + | 1952 -> One (r1288) + | 1956 -> One (r1289) + | 1960 -> One (r1290) + | 1963 -> One (r1291) + | 1967 -> One (r1292) + | 1973 -> One (r1293) + | 1983 -> One (r1294) + | 1985 -> One (r1295) + | 1988 -> One (r1296) + | 1987 -> One (r1297) + | 1990 -> One (r1298) + | 2000 -> One (r1299) + | 1996 -> One (r1300) + | 1995 -> One (r1301) + | 1999 -> One (r1302) + | 1998 -> One (r1303) + | 2005 -> One (r1304) + | 2004 -> One (r1305) + | 2003 -> One (r1306) + | 2007 -> One (r1307) + | 370 -> Select (function + | -1 -> [R 98] + | _ -> S (T T_DOT) :: r343) + | 611 -> Select (function + | -1 -> [R 98] + | _ -> r538) + | 130 -> Select (function + | -1 -> r82 + | _ -> R 124 :: r104) + | 172 -> Select (function + | -1 -> r82 + | _ -> R 124 :: r159) + | 1315 -> Select (function + | -1 -> r944 + | _ -> R 124 :: r937) + | 1343 -> Select (function + | -1 -> r895 + | _ -> R 124 :: r969) + | 495 -> Select (function + | -1 -> r296 + | _ -> [R 255]) + | 388 -> Select (function + | -1 -> [R 722] + | _ -> S (N N_pattern) :: r351) + | 385 -> Select (function + | -1 -> [R 723] + | _ -> S (N N_pattern) :: r350) + | 136 -> Select (function + | -1 -> r110 + | _ -> R 828 :: r116) | 175 -> Select (function - | -1 -> r150 - | _ -> r143) + | -1 -> r110 + | _ -> R 828 :: r165) + | 1320 -> Select (function + | -1 -> S (T T_RPAREN) :: r134 + | _ -> S (T T_COLONCOLON) :: r359) + | 198 -> Select (function + | 249 | 626 | 836 | 1029 | 1199 | 1674 | 1708 -> r47 + | -1 -> S (T T_RPAREN) :: r134 + | _ -> S (N N_pattern) :: r193) + | 244 -> Select (function + | -1 -> S (T T_RPAREN) :: r134 + | _ -> Sub (r3) :: r241) + | 251 -> Select (function + | -1 -> S (T T_RBRACKET) :: r252 + | _ -> Sub (r254) :: r256) + | 537 -> Select (function + | -1 -> S (T T_RBRACKET) :: r252 + | _ -> Sub (r451) :: r453) + | 449 -> Select (function + | 60 | 169 | 181 | 214 | 1288 | 1294 -> r394 + | _ -> S (T T_OPEN) :: r386) + | 1322 -> Select (function + | -1 -> r444 + | _ -> S (T T_LPAREN) :: r945) + | 287 -> Select (function + | 1484 | 1488 | 1492 | 1495 | 1509 | 1713 | 1737 -> r290 + | -1 -> r302 + | _ -> S (T T_DOT) :: r305) + | 493 -> Select (function + | -1 -> r302 + | _ -> S (T T_DOT) :: r439) + | 162 -> Select (function + | -1 -> r83 + | _ -> S (T T_COLON) :: r138) + | 113 -> Select (function + | 840 | 1180 -> r62 + | _ -> Sub (r59) :: r60) + | 116 -> Select (function + | 840 | 1180 -> r61 + | _ -> r60) + | 1825 -> Select (function + | -1 -> r78 + | _ -> r83) + | 1881 -> Select (function + | -1 -> r78 + | _ -> r83) + | 1880 -> Select (function + | -1 -> r79 + | _ -> r102) + | 1824 -> Select (function + | -1 -> r79 + | _ -> r157) + | 132 -> Select (function + | -1 -> r80 + | _ -> r103) | 174 -> Select (function - | -1 -> r151 - | _ -> r144) - | 917 -> Select (function - | -1 -> r149 - | _ -> r717) - | 866 -> Select (function - | -1 -> r150 - | _ -> r718) - | 865 -> Select (function - | -1 -> r151 - | _ -> r719) - | 197 -> Select (function - | -1 -> r163 + | -1 -> r80 | _ -> r158) - | 868 -> Select (function - | -1 -> r163 - | _ -> r725) - | 277 -> Select (function - | -1 -> r279 - | _ -> r282) - | 505 -> Select (function - | -1 -> r279 - | _ -> r444) - | 946 -> Select (function - | -1 -> r621 - | _ -> r764) - | 945 -> Select (function - | -1 -> r622 - | _ -> r765) - | 944 -> Select (function - | -1 -> r623 - | _ -> r766) - | 815 -> Select (function - | -1 -> r674 - | _ -> r668) - | 809 -> Select (function - | -1 -> r675 - | _ -> r669) - | 808 -> Select (function - | -1 -> r676 - | _ -> r670) + | 131 -> Select (function + | -1 -> r81 + | _ -> r104) + | 173 -> Select (function + | -1 -> r81 + | _ -> r159) + | 177 -> Select (function + | -1 -> r108 + | _ -> r83) + | 155 -> Select (function + | -1 -> r108 + | _ -> r83) + | 154 -> Select (function + | -1 -> r109 + | _ -> r116) + | 176 -> Select (function + | -1 -> r109 + | _ -> r165) + | 288 -> Select (function + | 1484 | 1488 | 1492 | 1495 | 1509 | 1713 | 1737 -> r289 + | -1 -> r297 + | _ -> r305) + | 494 -> Select (function + | -1 -> r297 + | _ -> r439) + | 1346 -> Select (function + | -1 -> r892 + | _ -> r967) + | 1345 -> Select (function + | -1 -> r893 + | _ -> r968) + | 1344 -> Select (function + | -1 -> r894 + | _ -> r969) + | 1318 -> Select (function + | -1 -> r941 + | _ -> r935) + | 1317 -> Select (function + | -1 -> r942 + | _ -> r936) + | 1316 -> Select (function + | -1 -> r943 + | _ -> r937) | _ -> raise Not_found diff --git a/src/ocaml/typing/annot.mli b/src/ocaml/typing/annot.mli index 3cae8f2735..bbaade5b03 100644 --- a/src/ocaml/typing/annot.mli +++ b/src/ocaml/typing/annot.mli @@ -15,10 +15,9 @@ (* Data types for annotations (Stypes.ml) *) -type call = Tail | Stack | Inline;; +type call = Tail | Stack | Inline type ident = | Iref_internal of Location.t (* defining occurrence *) | Iref_external | Idef of Location.t (* scope *) -;; diff --git a/src/ocaml/typing/btype.ml b/src/ocaml/typing/btype.ml index e1f3b299f0..5ce396ecd2 100644 --- a/src/ocaml/typing/btype.ml +++ b/src/ocaml/typing/btype.ml @@ -46,8 +46,11 @@ end module TransientTypeHash = Hashtbl.Make(TransientTypeOps) module TypeHash = struct include TransientTypeHash + let mem hash = wrap_repr (mem hash) let add hash = wrap_repr (add hash) + let remove hash = wrap_repr (remove hash) let find hash = wrap_repr (find hash) + let find_opt hash = wrap_repr (find_opt hash) let iter f = TransientTypeHash.iter (wrap_type_expr f) end module TransientTypePairs = @@ -124,6 +127,12 @@ let newmarkedgenvar () = let is_Tvar ty = match get_desc ty with Tvar _ -> true | _ -> false let is_Tunivar ty = match get_desc ty with Tunivar _ -> true | _ -> false let is_Tconstr ty = match get_desc ty with Tconstr _ -> true | _ -> false +let type_kind_is_abstract decl = + match decl.type_kind with Type_abstract _ -> true | _ -> false +let type_origin decl = + match decl.type_kind with + | Type_abstract origin -> origin + | Type_variant _ | Type_record _ | Type_open -> Definition let dummy_method = "*dummy method*" @@ -322,7 +331,7 @@ let map_type_expr_cstr_args f = function Cstr_record (List.map (fun d -> {d with ld_type=f d.ld_type}) lbls) let iter_type_expr_kind f = function - | Type_abstract -> () + | Type_abstract _ -> () | Type_variant (cstrs, _) -> List.iter (fun cd -> diff --git a/src/ocaml/typing/btype.mli b/src/ocaml/typing/btype.mli index b495555b20..71dd67b74a 100644 --- a/src/ocaml/typing/btype.mli +++ b/src/ocaml/typing/btype.mli @@ -39,8 +39,11 @@ module TypeMap : sig end module TypeHash : sig include Hashtbl.S with type key = transient_expr + val mem: 'a t -> type_expr -> bool val add: 'a t -> type_expr -> 'a -> unit + val remove: 'a t -> type_expr -> unit val find: 'a t -> type_expr -> 'a + val find_opt: 'a t -> type_expr -> 'a option val iter: (type_expr -> 'a -> unit) -> 'a t -> unit end module TypePairs : sig @@ -77,6 +80,8 @@ val is_Tvar: type_expr -> bool val is_Tunivar: type_expr -> bool val is_Tconstr: type_expr -> bool val dummy_method: label +val type_kind_is_abstract: type_declaration -> bool +val type_origin : type_declaration -> type_origin (**** polymorphic variants ****) diff --git a/src/ocaml/typing/cmi_format.ml b/src/ocaml/typing/cmi_format.ml index 2c5999db01..3fae802d60 100644 --- a/src/ocaml/typing/cmi_format.ml +++ b/src/ocaml/typing/cmi_format.ml @@ -19,7 +19,6 @@ type pers_flags = | Rectypes | Alerts of alerts | Opaque - | Unsafe_string (* these type abbreviations are not exported; they are used to provide consistency across @@ -75,14 +74,17 @@ let read_cmi filename = raise (Error e) let output_cmi filename oc cmi = + ignore (filename, oc, cmi); "" +(* (* beware: the provided signature must have been substituted for saving *) output_string oc Config.cmi_magic_number; - output_value oc ((cmi.cmi_name, cmi.cmi_sign) : header); + Marshal.(to_channel oc ((cmi.cmi_name, cmi.cmi_sign) : header) [Compression]); flush oc; let crc = Digest.file filename in let crcs = (cmi.cmi_name, Some crc) :: cmi.cmi_crcs in output_value oc (crcs : crcs); output_value oc (cmi.cmi_flags : flags); crc +*) (* Error report moved to src/ocaml/typing/magic_numbers.ml *) diff --git a/src/ocaml/typing/cmi_format.mli b/src/ocaml/typing/cmi_format.mli index 2ce923f968..179dce38c7 100644 --- a/src/ocaml/typing/cmi_format.mli +++ b/src/ocaml/typing/cmi_format.mli @@ -19,7 +19,6 @@ type pers_flags = | Rectypes | Alerts of alerts | Opaque - | Unsafe_string type cmi_infos = { cmi_name : modname; diff --git a/src/ocaml/typing/cmt_format.ml b/src/ocaml/typing/cmt_format.ml index 49a629879f..418a9d676e 100644 --- a/src/ocaml/typing/cmt_format.ml +++ b/src/ocaml/typing/cmt_format.ml @@ -70,27 +70,68 @@ type cmt_infos = { cmt_args : string array; cmt_sourcefile : string option; cmt_builddir : string; - cmt_loadpath : string list; + cmt_loadpath : Load_path.paths; cmt_source_digest : Digest.t option; cmt_initial_env : Env.t; cmt_imports : (string * Digest.t option) list; cmt_interface_digest : Digest.t option; cmt_use_summaries : bool; - cmt_uid_to_loc : Location.t Shape.Uid.Tbl.t; + cmt_uid_to_decl : item_declaration Shape.Uid.Tbl.t; cmt_impl_shape : Shape.t option; (* None for mli *) + cmt_ident_occurrences : + (Longident.t Location.loc * Shape_reduce.result) list } type error = Not_a_typedtree of string +let iter_on_parts (it : Tast_iterator.iterator) = function + | Partial_structure s -> it.structure it s + | Partial_structure_item s -> it.structure_item it s + | Partial_expression e -> it.expr it e + | Partial_pattern (_category, p) -> it.pat it p + | Partial_class_expr ce -> it.class_expr it ce + | Partial_signature s -> it.signature it s + | Partial_signature_item s -> it.signature_item it s + | Partial_module_type s -> it.module_type it s + +let iter_on_annots (it : Tast_iterator.iterator) = function + | Implementation s -> it.structure it s + | Interface s -> it.signature it s + | Packed _ -> () + | Partial_implementation array -> Array.iter (iter_on_parts it) array + | Partial_interface array -> Array.iter (iter_on_parts it) array + +let iter_on_declaration f decl = + match decl with + | Value vd -> f vd.val_val.val_uid decl; + | Value_binding vb -> + let bound_idents = let_bound_idents_full [vb] in + List.iter ~f:(fun (_, _, _, uid) -> f uid decl) bound_idents + | Type td -> + if not (Btype.is_row_name (Ident.name td.typ_id)) then + f td.typ_type.type_uid (Type td) + | Constructor cd -> f cd.cd_uid decl + | Extension_constructor ec -> f ec.ext_type.ext_uid decl; + | Label ld -> f ld.ld_uid decl + | Module md -> f md.md_uid decl + | Module_type mtd -> f mtd.mtd_uid decl + | Module_substitution ms -> f ms.ms_uid decl + | Module_binding mb -> f mb.mb_uid decl + | Class cd -> f cd.ci_decl.cty_uid decl + | Class_type ct -> f ct.ci_decl.cty_uid decl + +let iter_on_declarations ~(f: Shape.Uid.t -> item_declaration -> unit) = { + Tast_iterator.default_iterator with + item_declaration = (fun _sub decl -> iter_on_declaration f decl); +} + let need_to_clear_env = try ignore (Sys.getenv "OCAML_BINANNOT_WITHENV"); false with Not_found -> true let keep_only_summary = Env.keep_only_summary -open Tast_mapper - let cenv = {Tast_mapper.default with env = fun _sub env -> keep_only_summary env} @@ -119,13 +160,250 @@ let clear_env binary_annots = else binary_annots +(* Every typedtree node with a located longident corresponding to user-facing + syntax should be indexed. *) +let iter_on_occurrences + ~(f : namespace:Shape.Sig_component_kind.t -> + Env.t -> Path.t -> Longident.t Location.loc -> + unit) = + let path_in_type typ name = + match Types.get_desc typ with + | Tconstr (type_path, _, _) -> + Some (Path.Pdot (type_path, name)) + | _ -> None + in + let add_constructor_description env lid = + function + | { Types.cstr_tag = Cstr_extension (path, _); _ } -> + f ~namespace:Extension_constructor env path lid + | { Types.cstr_uid = Predef name; _} -> + let id = List.assoc name Predef.builtin_idents in + f ~namespace:Constructor env (Pident id) lid + | { Types.cstr_res; cstr_name; _ } -> + let path = path_in_type cstr_res cstr_name in + Option.iter ~f:(fun path -> f ~namespace:Constructor env path lid) path + in + let add_label env lid { Types.lbl_name; lbl_res; _ } = + let path = path_in_type lbl_res lbl_name in + Option.iter ~f:(fun path -> f ~namespace:Label env path lid) path + in + let with_constraint ~env (_path, _lid, with_constraint) = + match with_constraint with + | Twith_module (path', lid') | Twith_modsubst (path', lid') -> + f ~namespace:Module env path' lid' + | _ -> () + in + Tast_iterator.{ default_iterator with + + expr = (fun sub ({ exp_desc; exp_env; _ } as e) -> + (match exp_desc with + | Texp_ident (path, lid, _) -> + f ~namespace:Value exp_env path lid + | Texp_construct (lid, constr_desc, _) -> + add_constructor_description exp_env lid constr_desc + | Texp_field (_, lid, label_desc) + | Texp_setfield (_, lid, label_desc, _) -> + add_label exp_env lid label_desc + | Texp_new (path, lid, _) -> + f ~namespace:Class exp_env path lid + | Texp_record { fields; _ } -> + Array.iter (fun (label_descr, record_label_definition) -> + match record_label_definition with + | Overridden ( + { Location.txt; loc}, + {exp_loc; _}) + when not exp_loc.loc_ghost + && loc.loc_start = exp_loc.loc_start + && loc.loc_end = exp_loc.loc_end -> + (* In the presence of punning we want to index the label + even if it is ghosted *) + let lid = { Location.txt; loc = {loc with loc_ghost = false} } in + add_label exp_env lid label_descr + | Overridden (lid, _) -> add_label exp_env lid label_descr + | Kept _ -> ()) fields + | Texp_instvar (_self_path, path, name) -> + let lid = { name with txt = Longident.Lident name.txt } in + f ~namespace:Value exp_env path lid + | Texp_setinstvar (_self_path, path, name, _) -> + let lid = { name with txt = Longident.Lident name.txt } in + f ~namespace:Value exp_env path lid + | Texp_override (_self_path, modifs) -> + List.iter ~f:(fun (id, (name : string Location.loc), _exp) -> + let lid = { name with txt = Longident.Lident name.txt } in + f ~namespace:Value exp_env (Path.Pident id) lid) + modifs + | Texp_extension_constructor (lid, path) -> + f ~namespace:Extension_constructor exp_env path lid + | Texp_constant _ | Texp_let _ | Texp_function _ | Texp_apply _ + | Texp_match _ | Texp_try _ | Texp_tuple _ | Texp_variant _ | Texp_array _ + | Texp_ifthenelse _ | Texp_sequence _ | Texp_while _ | Texp_for _ + | Texp_send _ + | Texp_letmodule _ | Texp_letexception _ | Texp_assert _ | Texp_lazy _ + | Texp_object _ | Texp_pack _ | Texp_letop _ | Texp_unreachable + | Texp_open _ | Texp_hole -> ()); + default_iterator.expr sub e); + + (* Remark: some types get iterated over twice due to how constraints are + encoded in the typedtree. For example, in [let x : t = 42], [t] is + present in both a [Tpat_constraint] and a [Texp_constraint] node) *) + typ = + (fun sub ({ ctyp_desc; ctyp_env; _ } as ct) -> + (match ctyp_desc with + | Ttyp_constr (path, lid, _ctyps) -> + f ~namespace:Type ctyp_env path lid + | Ttyp_package {pack_path; pack_txt} -> + f ~namespace:Module_type ctyp_env pack_path pack_txt + | Ttyp_class (path, lid, _typs) -> + (* Deprecated syntax to extend a polymorphic variant *) + f ~namespace:Type ctyp_env path lid + | Ttyp_open (path, lid, _ct) -> + f ~namespace:Module ctyp_env path lid + | Ttyp_any | Ttyp_var _ | Ttyp_arrow _ | Ttyp_tuple _ | Ttyp_object _ + | Ttyp_alias _ | Ttyp_variant _ | Ttyp_poly _ -> ()); + default_iterator.typ sub ct); + + pat = + (fun (type a) sub + ({ pat_desc; pat_extra; pat_env; _ } as pat : a general_pattern) -> + (match pat_desc with + | Tpat_construct (lid, constr_desc, _, _) -> + add_constructor_description pat_env lid constr_desc + | Tpat_record (fields, _) -> + List.iter ~f:(fun (lid, label_descr, pat) -> + let lid = + let open Location in + (* In the presence of punning we want to index the label + even if it is ghosted *) + if (not pat.pat_loc.loc_ghost + && lid.loc.loc_start = pat.pat_loc.loc_start + && lid.loc.loc_end = pat.pat_loc.loc_end) + then {lid with loc = {lid.loc with loc_ghost = false}} + else lid + in + add_label pat_env lid label_descr) + fields + | Tpat_any | Tpat_var _ | Tpat_alias _ | Tpat_constant _ | Tpat_tuple _ + | Tpat_variant _ | Tpat_array _ | Tpat_lazy _ | Tpat_value _ + | Tpat_exception _ | Tpat_or _ -> ()); + List.iter ~f:(fun (pat_extra, _, _) -> + match pat_extra with + | Tpat_open (path, lid, _) -> + f ~namespace:Module pat_env path lid + | Tpat_type (path, lid) -> + f ~namespace:Type pat_env path lid + | Tpat_constraint _ | Tpat_unpack -> ()) + pat_extra; + default_iterator.pat sub pat); + + binding_op = (fun sub ({bop_op_path; bop_op_name; bop_exp; _} as bop) -> + let lid = { bop_op_name with txt = Longident.Lident bop_op_name.txt } in + f ~namespace:Value bop_exp.exp_env bop_op_path lid; + default_iterator.binding_op sub bop); + + module_expr = + (fun sub ({ mod_desc; mod_env; _ } as me) -> + (match mod_desc with + | Tmod_ident (path, lid) -> f ~namespace:Module mod_env path lid + | Tmod_structure _ | Tmod_functor _ | Tmod_apply _ | Tmod_apply_unit _ + | Tmod_constraint _ | Tmod_unpack _ | Tmod_hole -> ()); + default_iterator.module_expr sub me); + + open_description = + (fun sub ({ open_expr = (path, lid); open_env; _ } as od) -> + f ~namespace:Module open_env path lid; + default_iterator.open_description sub od); + + module_type = + (fun sub ({ mty_desc; mty_env; _ } as mty) -> + (match mty_desc with + | Tmty_ident (path, lid) -> + f ~namespace:Module_type mty_env path lid + | Tmty_with (_mty, l) -> + List.iter ~f:(with_constraint ~env:mty_env) l + | Tmty_alias (path, lid) -> + f ~namespace:Module mty_env path lid + | Tmty_signature _ | Tmty_functor _ | Tmty_typeof _ -> ()); + default_iterator.module_type sub mty); + + class_expr = + (fun sub ({ cl_desc; cl_env; _} as ce) -> + (match cl_desc with + | Tcl_ident (path, lid, _) -> f ~namespace:Class cl_env path lid + | Tcl_structure _ | Tcl_fun _ | Tcl_apply _ | Tcl_let _ + | Tcl_constraint _ | Tcl_open _ -> ()); + default_iterator.class_expr sub ce); + + class_type = + (fun sub ({ cltyp_desc; cltyp_env; _} as ct) -> + (match cltyp_desc with + | Tcty_constr (path, lid, _) -> f ~namespace:Class_type cltyp_env path lid + | Tcty_signature _ | Tcty_arrow _ | Tcty_open _ -> ()); + default_iterator.class_type sub ct); + + signature_item = + (fun sub ({ sig_desc; sig_env; _ } as sig_item) -> + (match sig_desc with + | Tsig_exception { + tyexn_constructor = { ext_kind = Text_rebind (path, lid)}} -> + f ~namespace:Extension_constructor sig_env path lid + | Tsig_modsubst { ms_manifest; ms_txt } -> + f ~namespace:Module sig_env ms_manifest ms_txt + | Tsig_typext { tyext_path; tyext_txt } -> + f ~namespace:Type sig_env tyext_path tyext_txt + | Tsig_value _ | Tsig_type _ | Tsig_typesubst _ | Tsig_exception _ + | Tsig_module _ | Tsig_recmodule _ | Tsig_modtype _ | Tsig_modtypesubst _ + | Tsig_open _ | Tsig_include _ | Tsig_class _ | Tsig_class_type _ + | Tsig_attribute _ -> ()); + default_iterator.signature_item sub sig_item); + + structure_item = + (fun sub ({ str_desc; str_env; _ } as str_item) -> + (match str_desc with + | Tstr_exception { + tyexn_constructor = { ext_kind = Text_rebind (path, lid)}} -> + f ~namespace:Extension_constructor str_env path lid + | Tstr_typext { tyext_path; tyext_txt } -> + f ~namespace:Type str_env tyext_path tyext_txt + | Tstr_eval _ | Tstr_value _ | Tstr_primitive _ | Tstr_type _ + | Tstr_exception _ | Tstr_module _ | Tstr_recmodule _ + | Tstr_modtype _ | Tstr_open _ | Tstr_class _ | Tstr_class_type _ + | Tstr_include _ | Tstr_attribute _ -> ()); + default_iterator.structure_item sub str_item) +} + +let index_declarations binary_annots = + let index : item_declaration Types.Uid.Tbl.t = Types.Uid.Tbl.create 16 in + let f uid fragment = Types.Uid.Tbl.add index uid fragment in + iter_on_annots (iter_on_declarations ~f) binary_annots; + index + +let index_occurrences binary_annots = + let index : (Longident.t Location.loc * Shape_reduce.result) list ref = + ref [] + in + let f ~namespace env path lid = + let not_ghost { Location.loc = { loc_ghost; _ }; _ } = not loc_ghost in + if not_ghost lid then + match Env.shape_of_path ~namespace env path with + | exception Not_found -> () + | { uid = Some (Predef _); _ } -> () + | path_shape -> + let result = Shape_reduce.local_reduce_for_uid env path_shape in + index := (lid, result) :: !index + in + iter_on_annots (iter_on_occurrences ~f) binary_annots; + !index + exception Error of error let input_cmt ic = (input_value ic : cmt_infos) let output_cmt oc cmt = + ignore (oc, cmt) + (* output_string oc Config.cmt_magic_number; - output_value oc (cmt : cmt_infos) + Marshal.(to_channel oc (cmt : cmt_infos) [Compression]) + *) let read filename = (* Printf.fprintf stderr "Cmt_format.read %s\n%!" filename; *) @@ -182,20 +460,29 @@ let set_saved_types l = saved_types := l let record_value_dependency _vd1 _vd2 = () -let save_cmt filename modname binary_annots sourcefile initial_env cmi shape = +let save_cmt target binary_annots initial_env cmi shape = if !Clflags.binary_annotations && not !Clflags.print_types then begin Misc.output_to_file_via_temporary - ~mode:[Open_binary] filename + ~mode:[Open_binary] (Unit_info.Artifact.filename target) (fun temp_file_name oc -> let this_crc = match cmi with | None -> None | Some cmi -> Some (output_cmi temp_file_name oc cmi) in + let sourcefile = Unit_info.Artifact.source_file target in + let cmt_ident_occurrences = + if !Clflags.store_occurrences then + index_occurrences binary_annots + else + [] + in + let cmt_annots = clear_env binary_annots in + let cmt_uid_to_decl = index_declarations cmt_annots in let source_digest = Option.map ~f:Digest.file sourcefile in let cmt = { - cmt_modname = modname; - cmt_annots = clear_env binary_annots; + cmt_modname = Unit_info.Artifact.modname target; + cmt_annots; cmt_value_dependencies = !value_deps; cmt_comments = []; cmt_args = Sys.argv; @@ -208,8 +495,9 @@ let save_cmt filename modname binary_annots sourcefile initial_env cmi shape = cmt_imports = List.sort ~cmp:compare (Env.imports ()); cmt_interface_digest = this_crc; cmt_use_summaries = need_to_clear_env; - cmt_uid_to_loc = Env.get_uid_to_loc_tbl (); + cmt_uid_to_decl; cmt_impl_shape = shape; + cmt_ident_occurrences; } in output_cmt oc cmt) end; diff --git a/src/ocaml/typing/cmt_format.mli b/src/ocaml/typing/cmt_format.mli index 43e09f1236..c316ccc70c 100644 --- a/src/ocaml/typing/cmt_format.mli +++ b/src/ocaml/typing/cmt_format.mli @@ -59,14 +59,16 @@ type cmt_infos = { cmt_args : string array; cmt_sourcefile : string option; cmt_builddir : string; - cmt_loadpath : string list; + cmt_loadpath : Load_path.paths; cmt_source_digest : string option; cmt_initial_env : Env.t; cmt_imports : crcs; cmt_interface_digest : Digest.t option; cmt_use_summaries : bool; - cmt_uid_to_loc : Location.t Shape.Uid.Tbl.t; + cmt_uid_to_decl : item_declaration Shape.Uid.Tbl.t; cmt_impl_shape : Shape.t option; (* None for mli *) + cmt_ident_occurrences : + (Longident.t Location.loc * Shape_reduce.result) list } type error = @@ -90,10 +92,8 @@ val read_cmi : string -> Cmi_format.cmi_infos (** [save_cmt filename modname binary_annots sourcefile initial_env cmi] writes a cmt(i) file. *) val save_cmt : - string -> (* filename.cmt to generate *) - string -> (* module name *) + Unit_info.Artifact.t -> binary_annots -> - string option -> (* source file *) Env.t -> (* initial env *) Cmi_format.cmi_infos option -> (* if a .cmi was generated *) Shape.t option -> @@ -112,7 +112,6 @@ val set_saved_types : binary_part list -> unit val record_value_dependency: Types.value_description -> Types.value_description -> unit - (* val is_magic_number : string -> bool @@ -124,3 +123,15 @@ val record_value_dependency: val read_signature : 'a -> string -> Types.signature * 'b list * 'c list *) + +val iter_on_declarations : + f:(Types.Uid.t -> item_declaration -> unit) + -> Tast_iterator.iterator + +val iter_on_occurrences : + f:(namespace:Shape.Sig_component_kind.t -> + Env.t -> + Path.t -> + Longident.t Location.loc -> + unit) + -> Tast_iterator.iterator diff --git a/src/ocaml/typing/ctype.ml b/src/ocaml/typing/ctype.ml index 33578fc863..970c637a94 100644 --- a/src/ocaml/typing/ctype.ml +++ b/src/ocaml/typing/ctype.ml @@ -122,11 +122,14 @@ let () = Location.register_error_of_exn (function | Tags (l, l') -> + let pp_tag ppf s = Format.fprintf ppf "`%s" s in + let inline_tag = Misc.Style.as_inline_code pp_tag in Some Location. (errorf ~loc:(in_file !input_name) - "In this program,@ variant constructors@ `%s and `%s@ \ - have the same hash value.@ Change one of them." l l' + "In this program,@ variant constructors@ %a and %a@ \ + have the same hash value.@ Change one of them." + inline_tag l inline_tag l' ) | _ -> None ) @@ -147,9 +150,11 @@ exception Incompatible let current_level = s_ref 0 let nongen_level = s_ref 0 -let global_level = s_ref 1 +let global_level = s_ref 0 let saved_level = s_ref [] + +(* merlin specific *) type levels = { current_level: int; nongen_level: int; global_level: int; saved_level: (int * int) list; } @@ -163,6 +168,7 @@ let set_levels l = nongen_level := l.nongen_level; global_level := l.global_level; saved_level := l.saved_level +(* end merlin specific *) let get_current_level () = !current_level let init_def level = current_level := level; nongen_level := level @@ -183,8 +189,46 @@ let create_scope () = init_def (!current_level + 1); !current_level +let wrap_end_def f = Misc.try_finally f ~always:end_def + +let with_local_level ?post f = + begin_def (); + let result = wrap_end_def f in + Option.iter (fun g -> g result) post; + result +let with_local_level_if cond f ~post = + if cond then with_local_level f ~post else f () +let with_local_level_iter f ~post = + begin_def (); + let result, l = wrap_end_def f in + List.iter post l; + result +let with_local_level_iter_if cond f ~post = + if cond then with_local_level_iter f ~post else fst (f ()) +let with_local_level_if_principal f ~post = + with_local_level_if !Clflags.principal f ~post +let with_local_level_iter_if_principal f ~post = + with_local_level_iter_if !Clflags.principal f ~post +let with_level ~level f = + begin_def (); init_def level; + let result = wrap_end_def f in + result +let with_level_if cond ~level f = + if cond then with_level ~level f else f () + +let with_local_level_for_class ?post f = + begin_class_def (); + let result = wrap_end_def f in + Option.iter (fun g -> g result) post; + result + +let with_raised_nongen_level f = + raise_nongen_level (); + wrap_end_def f + + let reset_global_level () = - global_level := !current_level + 1 + global_level := !current_level let increase_global_level () = let gl = !global_level in global_level := !current_level; @@ -192,14 +236,6 @@ let increase_global_level () = let restore_global_level gl = global_level := gl -(**** Whether a path points to an object type (with hidden row variable) ****) -let is_object_type path = - let name = - match path with Path.Pident id -> Ident.name id - | Path.Pdot(_, s) -> s - | Path.Papply _ -> assert false - in name.[0] = '#' - (**** Control tracing of GADT instances *) let trace_gadt_instances = ref false @@ -221,9 +257,8 @@ let wrap_trace_gadt_instances env f x = let simple_abbrevs = ref Mnil -let proper_abbrevs path tl abbrev = - if tl <> [] || !trace_gadt_instances || !Clflags.principal || - is_object_type path +let proper_abbrevs tl abbrev = + if tl <> [] || !trace_gadt_instances || !Clflags.principal then abbrev else simple_abbrevs @@ -245,49 +280,144 @@ let newconstr path tyl = newty (Tconstr (path, tyl, ref Mnil)) let none = newty (Ttuple []) (* Clearly ill-formed type *) -(**** unification mode ****) +(**** information for [Typecore.unify_pat_*] ****) + +module Pattern_env : sig + type t = private + { mutable env : Env.t; + equations_scope : int; + allow_recursive_equations : bool; } + val make: Env.t -> equations_scope:int -> allow_recursive_equations:bool -> t + val copy: ?equations_scope:int -> t -> t + val set_env: t -> Env.t -> unit +end = struct + type t = + { mutable env : Env.t; + equations_scope : int; + allow_recursive_equations : bool; } + let make env ~equations_scope ~allow_recursive_equations = + { env; + equations_scope; + allow_recursive_equations; } + let copy ?equations_scope penv = + let equations_scope = + match equations_scope with None -> penv.equations_scope | Some s -> s in + { penv with equations_scope } + let set_env penv env = penv.env <- env +end -type unification_mode = - | Expression (* unification in expression *) - | Pattern (* unification in pattern which may add local constraints *) +(**** unification mode ****) type equations_generation = | Forbidden | Allowed of { equated_types : TypePairs.t } -let umode = ref Expression -let equations_generation = ref Forbidden -let assume_injective = ref false -let allow_recursive_equation = ref false +type unification_environment = + | Expression of + { env : Env.t; + in_subst : bool; } + (* normal unification mode *) + | Pattern of + { penv : Pattern_env.t; + equations_generation : equations_generation; + assume_injective : bool; + unify_eq_set : TypePairs.t; } + (* GADT constraint unification mode: + only used for type indices of GADT constructors + during pattern matching. + This allows adding local constraints. *) + +let get_env = function + | Expression {env} -> env + | Pattern {penv} -> penv.env + +let set_env uenv env = + match uenv with + | Expression _ -> invalid_arg "Ctype.set_env" + | Pattern {penv} -> Pattern_env.set_env penv env + +let in_pattern_mode = function + | Expression _ -> false + | Pattern _ -> true + +let get_equations_scope = function + | Expression _ -> invalid_arg "Ctype.get_equations_scope" + | Pattern r -> r.penv.equations_scope + +let order_type_pair t1 t2 = + if get_id t1 <= get_id t2 then (t1, t2) else (t2, t1) + +let add_type_equality uenv t1 t2 = + match uenv with + | Expression _ -> invalid_arg "Ctype.add_type_equality" + | Pattern r -> TypePairs.add r.unify_eq_set (order_type_pair t1 t2) -let can_generate_equations () = - match !equations_generation with - | Forbidden -> false - | _ -> true +let unify_eq uenv t1 t2 = + eq_type t1 t2 || + match uenv with + | Expression _ -> false + | Pattern r -> TypePairs.mem r.unify_eq_set (order_type_pair t1 t2) + +(* unification during type constructor expansion: + This mode disables the propagation of the level and scope of + the row variable to the whole type during the unification. + (see unify_{row, fields} and PR #11771) *) +let in_subst_mode = function + | Expression {in_subst} -> in_subst + | Pattern _ -> false + +let can_generate_equations = function + | Expression _ | Pattern { equations_generation = Forbidden } -> false + | Pattern { equations_generation = Allowed _ } -> true + +(* Can only be called when generate_equations is true *) +let record_equation uenv t1 t2 = + match uenv with + | Expression _ | Pattern { equations_generation = Forbidden } -> + invalid_arg "Ctype.record_equation" + | Pattern { equations_generation = Allowed { equated_types } } -> + TypePairs.add equated_types (t1, t2) + +let can_assume_injective = function + | Expression _ -> false + | Pattern { assume_injective } -> assume_injective + +let in_counterexample uenv = + match uenv with + | Expression _ -> false + | Pattern { penv } -> penv.allow_recursive_equations -let set_mode_pattern ~generate ~injective ~allow_recursive f = - Misc.protect_refs - [ Misc.R (umode, Pattern); - Misc.R (equations_generation, generate); - Misc.R (assume_injective, injective); - Misc.R (allow_recursive_equation, allow_recursive); - ] f +let allow_recursive_equations uenv = + !Clflags.recursive_types || in_counterexample uenv + +(* Though without_* functions can be in a direct style, + CPS clarifies the structure of the code better. *) +let without_assume_injective uenv f = + match uenv with + | Expression _ as uenv -> f uenv + | Pattern r -> f (Pattern { r with assume_injective = false }) + +let without_generating_equations uenv f = + match uenv with + | Expression _ as uenv -> f uenv + | Pattern r -> f (Pattern { r with equations_generation = Forbidden }) (*** Checks for type definitions ***) -let in_current_module = function +let rec in_current_module = function | Path.Pident _ -> true | Path.Pdot _ | Path.Papply _ -> false + | Path.Pextra_ty (p, _) -> in_current_module p let in_pervasives p = in_current_module p && - try ignore (Env.find_type p Env.initial_safe_string); true + try ignore (Env.find_type p Env.initial); true with Not_found -> false let is_datatype decl= match decl.type_kind with Type_record _ | Type_variant _ | Type_open -> true - | Type_abstract -> false + | Type_abstract _ -> false (**********************************************) @@ -418,67 +548,54 @@ let rec filter_row_fields erase = function (* Check genericity of type schemes *) (**************************************) +type variable_kind = Row_variable | Type_variable +exception Non_closed of type_expr * variable_kind -exception Non_closed of type_expr * bool - -let free_variables = ref [] -let really_closed = ref None - -(* [free_vars_rec] collects the variables of the input type - expression into the [free_variables] reference. It is used for - several different things in the type-checker, with the following - bells and whistles: - - If [really_closed] is Some typing environment, types in the environment +(* [free_vars] collects the variables of the input type expression. It + is used for several different things in the type-checker, with the + following bells and whistles: + - If [env] is Some typing environment, types in the environment are expanded to check whether the apparently-free variable would vanish during expansion. - - We collect both type variables and row variables, paired with a boolean - that is [true] if we have a row variable. + - We collect both type variables and row variables, paired with + a [variable_kind] to distinguish them. - We do not count "virtual" free variables -- free variables stored in the abbreviation of an object type that has been expanded (we store the abbreviations for use when displaying the type). - The functions [free_vars] and [free_variables] below receive - a typing environment as an optional [?env] parameter and - set [really_closed] accordingly. [free_vars] returns a [(variable * bool) list], while - [free_variables] drops the type/row information + [free_variables] below drops the type/row information and only returns a [variable list]. *) -let rec free_vars_rec real ty = - if try_mark_node ty then - match get_desc ty, !really_closed with - Tvar _, _ -> - free_variables := (ty, real) :: !free_variables - | Tconstr (path, tl, _), Some env -> - begin try - let (_, body, _) = Env.find_type_expansion path env in - if get_level body <> generic_level then - free_variables := (ty, real) :: !free_variables - with Not_found -> () - end; - List.iter (free_vars_rec true) tl -(* Do not count "virtual" free variables - | Tobject(ty, {contents = Some (_, p)}) -> - free_vars_rec false ty; List.iter (free_vars_rec true) p -*) - | Tobject (ty, _), _ -> - free_vars_rec false ty - | Tfield (_, _, ty1, ty2), _ -> - free_vars_rec true ty1; free_vars_rec false ty2 - | Tvariant row, _ -> - iter_row (free_vars_rec true) row; - if not (static_row row) then free_vars_rec false (row_more row) - | _ -> - iter_type_expr (free_vars_rec true) ty - let free_vars ?env ty = - free_variables := []; - really_closed := env; - free_vars_rec true ty; - let res = !free_variables in - free_variables := []; - really_closed := None; - res + let rec fv ~kind acc ty = + if not (try_mark_node ty) then acc + else match get_desc ty, env with + | Tvar _, _ -> + (ty, kind) :: acc + | Tconstr (path, tl, _), Some env -> + let acc = + match Env.find_type_expansion path env with + | exception Not_found -> acc + | (_, body, _) -> + if get_level body = generic_level then acc + else (ty, kind) :: acc + in + List.fold_left (fv ~kind:Type_variable) acc tl + | Tobject (ty, _), _ -> + (* ignoring the second parameter of [Tobject] amounts to not + counting "virtual free variables". *) + fv ~kind:Row_variable acc ty + | Tfield (_, _, ty1, ty2), _ -> + let acc = fv ~kind:Type_variable acc ty1 in + fv ~kind:Row_variable acc ty2 + | Tvariant row, _ -> + let acc = fold_row (fv ~kind:Type_variable) acc row in + if static_row row then acc + else fv ~kind:Row_variable acc (row_more row) + | _ -> + fold_type_expr (fv ~kind) acc ty + in fv ~kind:Type_variable [] ty let free_variables ?env ty = let tl = List.map fst (free_vars ?env ty) in @@ -502,7 +619,7 @@ let closed_type_decl decl = try List.iter mark_type decl.type_params; begin match decl.type_kind with - Type_abstract -> + Type_abstract _ -> () | Type_variant (v, _rep) -> List.iter @@ -542,7 +659,12 @@ let closed_extension_constructor ext = unmark_extension_constructor ext; Some ty -exception CCFailure of (type_expr * bool * string * type_expr) +type closed_class_failure = { + free_variable: type_expr * variable_kind; + meth: string; + meth_ty: type_expr; +} +exception CCFailure of closed_class_failure let closed_class params sign = List.iter mark_type params; @@ -551,8 +673,12 @@ let closed_class params sign = Meths.iter (fun lab (priv, _, ty) -> if priv = Mpublic then begin - try closed_type ty with Non_closed (ty0, real) -> - raise (CCFailure (ty0, real, lab, ty)) + try closed_type ty with Non_closed (ty0, variable_kind) -> + raise (CCFailure { + free_variable = (ty0, variable_kind); + meth = lab; + meth_ty = ty; + }) end) sign.csig_meths; List.iter unmark_type params; @@ -613,13 +739,12 @@ let rec generalize_structure ty = if level <> generic_level then begin if is_Tvar ty && level > !current_level then set_level ty !current_level - else if - level > !current_level && - match get_desc ty with - Tconstr (p, _, abbrev) -> - not (is_object_type p) && (abbrev := Mnil; true) - | _ -> true - then begin + else if level > !current_level then begin + begin match get_desc ty with + Tconstr (_, _, abbrev) -> + abbrev := Mnil + | _ -> () + end; set_level ty generic_level; iter_type_expr generalize_structure ty end @@ -648,7 +773,7 @@ let rec generalize_spine ty = | Tpackage (_, fl) -> set_level ty generic_level; List.iter (fun (_n, ty) -> generalize_spine ty) fl - | Tconstr (p, tyl, memo) when not (is_object_type p) -> + | Tconstr (_, tyl, memo) -> set_level ty generic_level; memo := Mnil; List.iter generalize_spine tyl @@ -825,7 +950,7 @@ let rec lower_contravariant env var_level visited contra ty = try let typ = Env.find_type path env in typ.type_variance, - typ.type_kind = Type_abstract + type_kind_is_abstract typ with Not_found -> (* See testsuite/tests/typing-missing-cmi-2 for an example *) List.map (fun _ -> Variance.unknown) tyl, @@ -888,46 +1013,42 @@ let correct_levels ty = (* Only generalize the type ty0 in ty *) let limited_generalize ty0 ty = - let graph = Hashtbl.create 17 in - let idx = ref lowest_level in + let graph = TypeHash.create 17 in let roots = ref [] in let rec inverse pty ty = - let level = get_level ty in - if (level > !current_level) || (level = generic_level) then begin - decr idx; - Hashtbl.add graph !idx (ty, ref pty); - if (level = generic_level) || eq_type ty ty0 then - roots := ty :: !roots; - set_level ty !idx; - iter_type_expr (inverse [ty]) ty - end else if level < lowest_level then begin - let (_, parents) = Hashtbl.find graph level in - parents := pty @ !parents - end + match TypeHash.find_opt graph ty with + | Some parents -> parents := pty @ !parents + | None -> + let level = get_level ty in + if level > !current_level then begin + TypeHash.add graph ty (ref pty); + (* XXX: why generic_level needs to be a root *) + if (level = generic_level) || eq_type ty ty0 then + roots := ty :: !roots; + iter_type_expr (inverse [ty]) ty + end + in - and generalize_parents ty = - let idx = get_level ty in - if idx <> generic_level then begin + let rec generalize_parents ~is_root ty = + if is_root || get_level ty <> generic_level then begin set_level ty generic_level; - List.iter generalize_parents !(snd (Hashtbl.find graph idx)); + List.iter (generalize_parents ~is_root:false) !(TypeHash.find graph ty); (* Special case for rows: must generalize the row variable *) match get_desc ty with Tvariant row -> let more = row_more row in let lv = get_level more in - if (lv < lowest_level || lv > !current_level) - && lv <> generic_level then set_level more generic_level + if (TypeHash.mem graph more || lv > !current_level) + && lv <> generic_level then set_level more generic_level | _ -> () end in inverse [] ty; - if get_level ty0 < lowest_level then - iter_type_expr (inverse []) ty0; - List.iter generalize_parents !roots; - Hashtbl.iter - (fun _ (ty, _) -> + List.iter (generalize_parents ~is_root:true) !roots; + TypeHash.iter + (fun ty _ -> if get_level ty <> generic_level then set_level ty !current_level) graph @@ -1005,20 +1126,22 @@ let rec find_repr p1 = (* Generic nodes are duplicated, while non-generic nodes are left as-is. - During instantiation, the description of a generic node is first - replaced by a link to a stub ([Tsubst (newvar ())]). Once the - copy is made, it replaces the stub. - After instantiation, the description of generic node, which was - stored by [save_desc], must be put back, using [cleanup_types]. -*) + + During instantiation, the result of copying a generic node is + "cached" in-place by temporarily mutating the node description by + a stub [Tsubst (newvar ())] using [For_copy.redirect_desc]. The + scope of this mutation is determined by the [copy_scope] parameter, + and the [For_copy.with_scope] helper is in charge of creating a new + scope and performing the necessary book-keeping -- in particular + reverting the in-place updates after the instantiation is done. *) let abbreviations = ref (ref Mnil) (* Abbreviation memorized. *) (* partial: we may not wish to copy the non generic types before we call type_pat *) -let rec copy ?partial ?keep_names scope ty = - let copy = copy ?partial ?keep_names scope in +let rec copy ?partial ?keep_names copy_scope ty = + let copy = copy ?partial ?keep_names copy_scope in match get_desc ty with Tsubst (ty, _) -> ty | desc -> @@ -1037,11 +1160,11 @@ let rec copy ?partial ?keep_names scope ty = in if forget <> generic_level then newty2 ~level:forget (Tvar None) else let t = newstub ~scope:(get_scope ty) in - For_copy.redirect_desc scope ty (Tsubst (t, None)); + For_copy.redirect_desc copy_scope ty (Tsubst (t, None)); let desc' = match desc with | Tconstr (p, tl, _) -> - let abbrevs = proper_abbrevs p tl !abbreviations in + let abbrevs = proper_abbrevs tl !abbreviations in begin match find_repr p !abbrevs with Some ty when not (eq_type ty t) -> Tlink ty @@ -1069,7 +1192,7 @@ let rec copy ?partial ?keep_names scope ty = Tsubst (_, Some ty2) -> (* This variant type has been already copied *) (* Change the stub to avoid Tlink in the new type *) - For_copy.redirect_desc scope ty (Tsubst (ty2, None)); + For_copy.redirect_desc copy_scope ty (Tsubst (ty2, None)); Tlink ty2 | _ -> (* If the row variable is not generic, we must keep it *) @@ -1097,12 +1220,6 @@ let rec copy ?partial ?keep_names scope ty = let more', row = match partial with Some (free_univars, false) -> - let more' = - if not (eq_type more more') then - more' (* we've already made a copy *) - else - newvar () - in let not_reither (_, f) = match row_field_repr f with Reither _ -> false @@ -1112,6 +1229,7 @@ let rec copy ?partial ?keep_names scope ty = if row_closed row && not (is_fixed row) && TypeSet.is_empty (free_univars ty) && not (List.for_all not_reither fields) then + let more' = newvar () in (more', create_row ~fields:(List.filter not_reither fields) ~more:more' ~closed:false ~fixed:None ~name:None) @@ -1119,7 +1237,7 @@ let rec copy ?partial ?keep_names scope ty = | _ -> (more', row) in (* Register new type first for recursion *) - For_copy.redirect_desc scope more + For_copy.redirect_desc copy_scope more (Tsubst(more', Some t)); (* Return a new copy *) Tvariant (copy_row copy true row keep more') @@ -1139,7 +1257,8 @@ let instance ?partial sch = None -> None | Some keep -> Some (compute_univars sch, keep) in - For_copy.with_scope (fun scope -> copy ?partial scope sch) + For_copy.with_scope (fun copy_scope -> + copy ?partial copy_scope sch) let generic_instance sch = let old = !current_level in @@ -1149,24 +1268,25 @@ let generic_instance sch = ty let instance_list schl = - For_copy.with_scope (fun scope -> List.map (fun t -> copy scope t) schl) - -let reified_var_counter = ref Vars.empty -let reset_reified_var_counter () = - reified_var_counter := Vars.empty - -(* names given to new type constructors. - Used for existential types and - local constraints *) -let get_new_abstract_name s = - let index = - try Vars.find s !reified_var_counter + 1 - with Not_found -> 0 in - reified_var_counter := Vars.add s index !reified_var_counter; - if index = 0 && s <> "" && s.[String.length s - 1] <> '$' then s else - Printf.sprintf "%s%d" s index - -let new_local_type ?(loc = Location.none) ?manifest_and_scope () = + For_copy.with_scope (fun copy_scope -> + List.map (fun t -> copy copy_scope t) schl) + +(* Create unique names to new type constructors. + Used for existential types and local constraints. *) +let get_new_abstract_name env s = + let name index = + if index = 0 && s <> "" && s.[String.length s - 1] <> '$' then s else + Printf.sprintf "%s%d" s index + in + let check index = + match Env.find_type_by_name (Longident.Lident (name index)) env with + | _ -> false + | exception Not_found -> true + in + let index = Misc.find_first_mono check in + name index + +let new_local_type ?(loc = Location.none) ?manifest_and_scope origin = let manifest, expansion_scope = match manifest_and_scope with None -> None, Btype.lowest_level @@ -1175,7 +1295,7 @@ let new_local_type ?(loc = Location.none) ?manifest_and_scope () = { type_params = []; type_arity = 0; - type_kind = Type_abstract; + type_kind = Type_abstract origin; type_private = Public; type_manifest = manifest; type_variance = []; @@ -1189,53 +1309,58 @@ let new_local_type ?(loc = Location.none) ?manifest_and_scope () = type_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); } -let existential_name cstr ty = - match get_desc ty with - | Tvar (Some name) -> "$" ^ cstr.cstr_name ^ "_'" ^ name - | _ -> "$" ^ cstr.cstr_name - -let instance_constructor ?in_pattern cstr = - For_copy.with_scope (fun scope -> - begin match in_pattern with - | None -> () - | Some (env, fresh_constr_scope) -> - let process existential = - let decl = new_local_type () in - let name = existential_name cstr existential in - let (id, new_env) = - Env.enter_type (get_new_abstract_name name) decl !env - ~scope:fresh_constr_scope in - env := new_env; - let to_unify = newty (Tconstr (Path.Pident id,[],ref Mnil)) in - let tv = copy scope existential in - assert (is_Tvar tv); - link_type tv to_unify - in - List.iter process cstr.cstr_existentials - end; - let ty_res = copy scope cstr.cstr_res in - let ty_args = List.map (copy scope) cstr.cstr_args in - let ty_ex = List.map (copy scope) cstr.cstr_existentials in +let existential_name name_counter ty = + let name = + match get_desc ty with + | Tvar (Some name) -> name + | _ -> + let name = Misc.letter_of_int !name_counter in + incr name_counter; + name + in + "$" ^ name + +type existential_treatment = + | Keep_existentials_flexible + | Make_existentials_abstract of Pattern_env.t + +let instance_constructor existential_treatment cstr = + For_copy.with_scope (fun copy_scope -> + let name_counter = ref 0 in + let copy_existential = + match existential_treatment with + | Keep_existentials_flexible -> copy copy_scope + | Make_existentials_abstract penv -> + fun existential -> + let env = penv.env in + let fresh_constr_scope = penv.equations_scope in + let decl = new_local_type (Existential cstr.cstr_name) in + let name = existential_name name_counter existential in + let (id, new_env) = + Env.enter_type (get_new_abstract_name env name) decl env + ~scope:fresh_constr_scope in + Pattern_env.set_env penv new_env; + let to_unify = newty (Tconstr (Path.Pident id,[],ref Mnil)) in + let tv = copy copy_scope existential in + assert (is_Tvar tv); + link_type tv to_unify; + tv + in + let ty_ex = List.map copy_existential cstr.cstr_existentials in + let ty_res = copy copy_scope cstr.cstr_res in + let ty_args = List.map (copy copy_scope) cstr.cstr_args in (ty_args, ty_res, ty_ex) ) let instance_parameterized_type ?keep_names sch_args sch = - For_copy.with_scope (fun scope -> - let ty_args = List.map (fun t -> copy ?keep_names scope t) sch_args in - let ty = copy scope sch in + For_copy.with_scope (fun copy_scope -> + let ty_args = List.map (fun t -> copy ?keep_names copy_scope t) sch_args in + let ty = copy copy_scope sch in (ty_args, ty) ) -let instance_parameterized_type_2 sch_args sch_lst sch = - For_copy.with_scope (fun scope -> - let ty_args = List.map (copy scope) sch_args in - let ty_lst = List.map (copy scope) sch_lst in - let ty = copy scope sch in - (ty_args, ty_lst, ty) - ) - let map_kind f = function - | Type_abstract -> Type_abstract + | Type_abstract r -> Type_abstract r | Type_open -> Type_open | Type_variant (cl, rep) -> Type_variant ( @@ -1255,10 +1380,10 @@ let map_kind f = function let instance_declaration decl = - For_copy.with_scope (fun scope -> - {decl with type_params = List.map (copy scope) decl.type_params; - type_manifest = Option.map (copy scope) decl.type_manifest; - type_kind = map_kind (copy scope) decl.type_kind; + For_copy.with_scope (fun copy_scope -> + {decl with type_params = List.map (copy copy_scope) decl.type_params; + type_manifest = Option.map (copy copy_scope) decl.type_manifest; + type_kind = map_kind (copy copy_scope) decl.type_kind; } ) @@ -1270,107 +1395,105 @@ let generic_instance_declaration decl = decl let instance_class params cty = - let rec copy_class_type scope = function + let rec copy_class_type copy_scope = function | Cty_constr (path, tyl, cty) -> - let tyl' = List.map (copy scope) tyl in - let cty' = copy_class_type scope cty in + let tyl' = List.map (copy copy_scope) tyl in + let cty' = copy_class_type copy_scope cty in Cty_constr (path, tyl', cty') | Cty_signature sign -> Cty_signature - {csig_self = copy scope sign.csig_self; - csig_self_row = copy scope sign.csig_self_row; + {csig_self = copy copy_scope sign.csig_self; + csig_self_row = copy copy_scope sign.csig_self_row; csig_vars = Vars.map - (function (m, v, ty) -> (m, v, copy scope ty)) + (function (m, v, ty) -> (m, v, copy copy_scope ty)) sign.csig_vars; csig_meths = Meths.map - (function (p, v, ty) -> (p, v, copy scope ty)) + (function (p, v, ty) -> (p, v, copy copy_scope ty)) sign.csig_meths} | Cty_arrow (l, ty, cty) -> - Cty_arrow (l, copy scope ty, copy_class_type scope cty) + Cty_arrow (l, copy copy_scope ty, copy_class_type copy_scope cty) in - For_copy.with_scope (fun scope -> - let params' = List.map (copy scope) params in - let cty' = copy_class_type scope cty in + For_copy.with_scope (fun copy_scope -> + let params' = List.map (copy copy_scope) params in + let cty' = copy_class_type copy_scope cty in (params', cty') ) (**** Instantiation for types with free universal variables ****) -let rec diff_list l1 l2 = - if l1 == l2 then [] else - match l1 with [] -> invalid_arg "Ctype.diff_list" - | a :: l1 -> a :: diff_list l1 l2 - -let conflicts free bound = - let bound = List.map get_id bound in - TypeSet.exists (fun t -> List.memq (get_id t) bound) free - -let delayed_copy = ref [] - (* copying to do later *) - -(* Copy without sharing until there are no free univars left *) -(* all free univars must be included in [visited] *) -let rec copy_sep ~cleanup_scope ~fixed ~free ~bound ~may_share - (visited : (int * (type_expr * type_expr list)) list) (ty : type_expr) = - let univars = free ty in - if is_Tvar ty || may_share && TypeSet.is_empty univars then - if get_level ty <> generic_level then ty else - let t = newstub ~scope:(get_scope ty) in - delayed_copy := - lazy (Transient_expr.set_stub_desc t (Tlink (copy cleanup_scope ty))) - :: !delayed_copy; - t - else try - let t, bound_t = List.assq (get_id ty) visited in - let dl = if is_Tunivar ty then [] else diff_list bound bound_t in - if dl <> [] && conflicts univars dl then raise Not_found; - t - with Not_found -> begin - let t = newstub ~scope:(get_scope ty) in - let desc = get_desc ty in - let visited = - match desc with - Tarrow _ | Ttuple _ | Tvariant _ | Tconstr _ | Tobject _ | Tpackage _ -> - (get_id ty, (t, bound)) :: visited - | Tvar _ | Tfield _ | Tnil | Tpoly _ | Tunivar _ -> - visited - | Tlink _ | Tsubst _ -> - assert false - in - let copy_rec = copy_sep ~cleanup_scope ~fixed ~free ~bound visited in - let desc' = - match desc with - | Tvariant row -> - let more = row_more row in - (* We shall really check the level on the row variable *) - let keep = is_Tvar more && get_level more <> generic_level in - let more' = copy_rec ~may_share:false more in - let fixed' = fixed && (is_Tvar more || is_Tunivar more) in - let row = - copy_row (copy_rec ~may_share:true) fixed' row keep more' in - Tvariant row - | Tpoly (t1, tl) -> - let tl' = List.map (fun t -> newty (get_desc t)) tl in - let bound = tl @ bound in - let visited = - List.map2 (fun ty t -> get_id ty, (t, bound)) tl tl' @ visited in - let body = - copy_sep ~cleanup_scope ~fixed ~free ~bound ~may_share:true - visited t1 in - Tpoly (body, tl') - | Tfield (p, k, ty1, ty2) -> - (* the kind is kept shared, see Btype.copy_type_desc *) - Tfield (p, field_kind_internal_repr k, copy_rec ~may_share:true ty1, - copy_rec ~may_share:false ty2) - | _ -> copy_type_desc (copy_rec ~may_share:true) desc - in - Transient_expr.set_stub_desc t desc'; - t - end +(* [copy_sep] is used to instantiate first-class polymorphic types. + * It first makes a separate copy of the type as a graph, omitting nodes + that have no free univars. + * In this first pass, [visited] is used as a mapping for previously visited + nodes, and must already contain all the free univars in [ty]. + * The remaining (univar-closed) parts of the type are then instantiated + with [copy] using a common [copy_scope]. + The reason to work in two passes lies in recursive types such as: + [let h (x : < m : 'a. < n : 'a; p : 'b > > as 'b) = x#m] + The type of [x#m] should be: + [ < n : 'c; p : < m : 'a. < n : 'a; p : 'b > > as 'b > ] + I.e., the universal type variable ['a] is both instantiated as a fresh + type variable ['c] when outside of its binder, and kept as universal + when under its binder. + Assumption: in the first call to [copy_sep], all the free univars should + be bound by the same [Tpoly] node. This guarantees that they are only + bound when under this [Tpoly] node, which has no free univars, and as + such is not part of the separate copy. In turn, this allows the separate + copy to keep the sharing of the original type without breaking its + binding structure. + *) +let copy_sep ~copy_scope ~fixed ~(visited : type_expr TypeHash.t) sch = + let free = compute_univars sch in + let delayed_copies = ref [] in + let add_delayed_copy t ty = + delayed_copies := + (fun () -> Transient_expr.set_stub_desc t (Tlink (copy copy_scope ty))) :: + !delayed_copies + in + let rec copy_rec ~may_share (ty : type_expr) = + let univars = free ty in + if is_Tvar ty || may_share && TypeSet.is_empty univars then + if get_level ty <> generic_level then ty else + let t = newstub ~scope:(get_scope ty) in + add_delayed_copy t ty; + t + else try + TypeHash.find visited ty + with Not_found -> begin + let t = newstub ~scope:(get_scope ty) in + TypeHash.add visited ty t; + let desc' = + match get_desc ty with + | Tvariant row -> + let more = row_more row in + (* We shall really check the level on the row variable *) + let keep = is_Tvar more && get_level more <> generic_level in + (* In that case we should keep the original, but we still + call copy to correct the levels *) + if keep then (add_delayed_copy t ty; Tvar None) else + let more' = copy_rec ~may_share:false more in + let fixed' = fixed && (is_Tvar more || is_Tunivar more) in + let row = + copy_row (copy_rec ~may_share:true) fixed' row keep more' in + Tvariant row + | Tfield (p, k, ty1, ty2) -> + (* the kind is kept shared, see Btype.copy_type_desc *) + Tfield (p, field_kind_internal_repr k, + copy_rec ~may_share:true ty1, + copy_rec ~may_share:false ty2) + | desc -> copy_type_desc (copy_rec ~may_share:true) desc + in + Transient_expr.set_stub_desc t desc'; + t + end + in + let ty = copy_rec ~may_share:true sch in + List.iter (fun force -> force ()) !delayed_copies; + ty -let instance_poly' cleanup_scope ~keep_names fixed univars sch = +let instance_poly' copy_scope ~keep_names ~fixed univars sch = (* In order to compute univars below, [sch] should not contain [Tsubst] *) let copy_var ty = match get_desc ty with @@ -1378,31 +1501,27 @@ let instance_poly' cleanup_scope ~keep_names fixed univars sch = | _ -> assert false in let vars = List.map copy_var univars in - let pairs = List.map2 (fun u v -> get_id u, (v, [])) univars vars in - delayed_copy := []; - let ty = - copy_sep ~cleanup_scope ~fixed ~free:(compute_univars sch) ~bound:[] - ~may_share:true pairs sch in - List.iter Lazy.force !delayed_copy; - delayed_copy := []; + let visited = TypeHash.create 17 in + List.iter2 (TypeHash.add visited) univars vars; + let ty = copy_sep ~copy_scope ~fixed ~visited sch in vars, ty -let instance_poly ?(keep_names=false) fixed univars sch = - For_copy.with_scope (fun cleanup_scope -> - instance_poly' cleanup_scope ~keep_names fixed univars sch +let instance_poly ?(keep_names=false) ~fixed univars sch = + For_copy.with_scope (fun copy_scope -> + instance_poly' copy_scope ~keep_names ~fixed univars sch ) -let instance_label fixed lbl = - For_copy.with_scope (fun scope -> +let instance_label ~fixed lbl = + For_copy.with_scope (fun copy_scope -> let vars, ty_arg = match get_desc lbl.lbl_arg with Tpoly (ty, tl) -> - instance_poly' scope ~keep_names:false fixed tl ty + instance_poly' copy_scope ~keep_names:false ~fixed tl ty | _ -> - [], copy scope lbl.lbl_arg + [], copy copy_scope lbl.lbl_arg in (* call [copy] after [instance_poly] to avoid introducing [Tsubst] *) - let ty_res = copy scope lbl.lbl_res in + let ty_res = copy copy_scope lbl.lbl_res in (vars, ty_arg, ty_res) ) @@ -1423,7 +1542,7 @@ let subst env level priv abbrev oty params args body = | Some ty -> match get_desc ty with Tconstr (path, tl, _) -> - let abbrev = proper_abbrevs path tl abbrev in + let abbrev = proper_abbrevs tl abbrev in memorize_abbrev abbrev priv path ty body0; fun () -> forget_abbrev abbrev path | _ -> assert false @@ -1431,9 +1550,10 @@ let subst env level priv abbrev oty params args body = abbreviations := abbrev; let (params', body') = instance_parameterized_type params body in abbreviations := ref Mnil; + let uenv = Expression {env; in_subst = true} in try - !unify_var' env body0 body'; - List.iter2 (!unify_var' env) params' args; + !unify_var' uenv body0 body'; + List.iter2 (!unify_var' uenv) params' args; current_level := old_level; body' with Unify _ -> @@ -1442,33 +1562,33 @@ let subst env level priv abbrev oty params args body = raise Cannot_subst (* - Only the shape of the type matters, not whether it is generic or - not. [generic_level] might be somewhat slower, but it ensures - invariants on types are enforced (decreasing levels), and we don't + Default to generic level. Usually, only the shape of the type matters, not + whether it is generic or not. [generic_level] might be somewhat slower, but + it ensures invariants on types are enforced (decreasing levels), and we don't care about efficiency here. *) -let apply env params body args = +let apply ?(use_current_level = false) env params body args = + simple_abbrevs := Mnil; + let level = if use_current_level then !current_level else generic_level in try - subst env generic_level Public (ref Mnil) None params args body + subst env level Public (ref Mnil) None params args body with Cannot_subst -> raise Cannot_apply -let () = Subst.ctype_apply_env_empty := apply Env.empty - (****************************) (* Abbreviation expansion *) (****************************) (* If the environment has changed, memorized expansions might not - be correct anymore, and so we flush the cache. This is safe but - quite pessimistic: it would be enough to flush the cache when a - type or module definition is overridden in the environment. + be correct anymore, and so we flush the cache. The test used + checks whether any of types, modules, or local constraints have + been changed. *) let previous_env = ref Env.empty (*let string_of_kind = function Public -> "public" | Private -> "private"*) let check_abbrev_env env = - if env != !previous_env then begin + if not (Env.same_type_declarations env !previous_env) then begin (* prerr_endline "cleanup expansion cache"; *) cleanup_abbrev (); previous_env := env @@ -1494,59 +1614,55 @@ let check_abbrev_env env = and this other expansion fails. *) let expand_abbrev_gen kind find_type_expansion env ty = + let path, args, abbrev = match get_desc ty with + | Tconstr (path,args,abbrev) -> path, args, abbrev + | _ -> assert false + in check_abbrev_env env; - match get_desc ty with - Tconstr (path, args, abbrev) -> - let level = get_level ty in - let scope = get_scope ty in - let lookup_abbrev = proper_abbrevs path args abbrev in - begin match find_expans kind path !lookup_abbrev with - Some ty' -> + let level = get_level ty in + let scope = get_scope ty in + let lookup_abbrev = proper_abbrevs args abbrev in + let expansion = + (* first look for an existing expansion *) + match find_expans kind path !lookup_abbrev with + | None -> None + | Some ty' -> try + (* prerr_endline + ("found a "^string_of_kind kind^" expansion for "^Path.name path);*) + if level <> generic_level then update_level env level ty'; + update_scope scope ty'; + Some ty' + with Escape _ -> + (* in case of Escape, discard the stale expansion and re-expand *) + forget_abbrev lookup_abbrev path; + None + in + begin match expansion with + | Some ty' -> ty' + | None -> + (* attempt to (re-)expand *) + match find_type_expansion path env with + | exception Not_found -> + (* another way to expand is to normalize the path itself *) + let path' = Env.normalize_type_path None env path in + if Path.same path path' then raise Cannot_expand + else newty2 ~level (Tconstr (path', args, abbrev)) + | (params, body, lv) -> (* prerr_endline - ("found a "^string_of_kind kind^" expansion for "^Path.name path);*) - if level <> generic_level then - begin try - update_level env level ty' - with Escape _ -> - (* XXX This should not happen. - However, levels are not correctly restored after a - typing error *) - () - end; - begin try - update_scope scope ty'; - with Escape _ -> - (* XXX This should not happen. - However, levels are not correctly restored after a - typing error *) - () - end; + ("add a "^string_of_kind kind^" expansion for "^Path.name path);*) + let ty' = + try + subst env level kind abbrev (Some ty) params args body + with Cannot_subst -> raise_escape_exn Constraint + in + (* For gadts, remember type as non exportable *) + (* The ambiguous level registered for ty' should be the highest *) + (* if !trace_gadt_instances then begin *) + let scope = Int.max lv (get_scope ty) in + update_scope scope ty; + update_scope scope ty'; ty' - | None -> - match find_type_expansion path env with - | exception Not_found -> - (* another way to expand is to normalize the path itself *) - let path' = Env.normalize_type_path None env path in - if Path.same path path' then raise Cannot_expand - else newty2 ~level (Tconstr (path', args, abbrev)) - | (params, body, lv) -> - (* prerr_endline - ("add a "^string_of_kind kind^" expansion for "^Path.name path);*) - let ty' = - try - subst env level kind abbrev (Some ty) params args body - with Cannot_subst -> raise_escape_exn Constraint - in - (* For gadts, remember type as non exportable *) - (* The ambiguous level registered for ty' should be the highest *) - (* if !trace_gadt_instances then begin *) - let scope = Int.max lv (get_scope ty) in - update_scope scope ty; - update_scope scope ty'; - ty' - end - | _ -> - assert false + end (* Expand respecting privacy *) let expand_abbrev env ty = @@ -1624,7 +1740,7 @@ let rec extract_concrete_typedecl env ty = begin match Env.find_type p env with | exception Not_found -> May_have_typedecl | decl -> - if decl.type_kind <> Type_abstract then Typedecl(p, p, decl) + if not (type_kind_is_abstract decl) then Typedecl(p, p, decl) else begin match try_expand_safe env ty with | exception Cannot_expand -> May_have_typedecl @@ -1682,16 +1798,12 @@ let full_expand ~may_forget_scope env ty = if may_forget_scope then try expand_head_unif env ty with Unify_trace _ -> (* #10277: forget scopes when printing trace *) - begin_def (); - init_def (get_level ty); - let ty = + with_level ~level:(get_level ty) begin fun () -> (* The same as [expand_head], except in the failing case we return the - *original* type, not [correct_levels ty].*) + *original* type, not [correct_levels ty].*) try try_expand_head try_expand_safe env (correct_levels ty) with | Cannot_expand -> ty - in - end_def (); - ty + end else expand_head env ty in match get_desc ty with @@ -1716,7 +1828,7 @@ let generic_abbrev env path = let generic_private_abbrev env path = try match Env.find_type path env with - {type_kind = Type_abstract; + {type_kind = Type_abstract _; type_private = Private; type_manifest = Some body} -> get_level body = generic_level @@ -1747,7 +1859,7 @@ let rec occur_rec env allow_recursive visited ty0 ty = let visited = TypeSet.add ty visited in iter_type_expr (occur_rec env allow_recursive visited ty0) ty with Occur -> try - let ty' = try_expand_head try_expand_once env ty in + let ty' = try_expand_head try_expand_safe env ty in (* This call used to be inlined, but there seems no reason for it. Message was referring to change in rev. 1.58 of the CVS repo. *) occur_rec env allow_recursive visited ty0 ty' @@ -1766,9 +1878,9 @@ let type_changed = ref false (* trace possible changes to the studied type *) let merge r b = if b then r := true -let occur env ty0 ty = - let allow_recursive = - !Clflags.recursive_types || !umode = Pattern && !allow_recursive_equation in +let occur uenv ty0 ty = + let env = get_env uenv in + let allow_recursive = allow_recursive_equations uenv in let old = !type_changed in try while @@ -1782,13 +1894,13 @@ let occur env ty0 ty = merge type_changed old; raise exn -let occur_for tr_exn env t1 t2 = +let occur_for tr_exn uenv t1 t2 = try - occur env t1 t2 + occur uenv t1 t2 with Occur -> raise_for tr_exn (Rec_occur(t1, t2)) let occur_in env ty0 t = - try occur env ty0 t; false with Occur -> true + try occur (Expression {env; in_subst = false}) ty0 t; false with Occur -> true (* Check that a local constraint is well-founded *) (* PR#6405: not needed since we allow recursion and work on normalized types *) @@ -1827,9 +1939,9 @@ let rec local_non_recursive_abbrev ~allow_rec strict visited env p ty = (local_non_recursive_abbrev ~allow_rec true visited env p) ty end -let local_non_recursive_abbrev env p ty = - let allow_rec = - !Clflags.recursive_types || !umode = Pattern && !allow_recursive_equation in +let local_non_recursive_abbrev uenv p ty = + let env = get_env uenv in + let allow_rec = allow_recursive_equations uenv in try (* PR#7397: need to check trace_gadt_instances *) wrap_trace_gadt_instances env (local_non_recursive_abbrev ~allow_rec false [] env p) ty; @@ -1843,14 +1955,12 @@ let local_non_recursive_abbrev env p ty = (* Since we cannot duplicate universal variables, unification must be done at meta-level, using bindings in univar_pairs *) -(* TODO: use find_opt *) let rec unify_univar t1 t2 = function (cl1, cl2) :: rem -> let find_univ t cl = - try - let (_, r) = List.find (fun (t',_) -> eq_type t t') cl in - Some r - with Not_found -> None + List.find_map (fun (t', r) -> + if eq_type t t' then Some r else None + ) cl in begin match find_univ t1 cl1, find_univ t2 cl2 with Some {contents=Some t'2}, Some _ when eq_type t2 t'2 -> @@ -2004,20 +2114,20 @@ let univar_pairs = ref [] (**** Instantiate a generic type into a poly type ***) let polyfy env ty vars = - let subst_univar scope ty = + let subst_univar copy_scope ty = match get_desc ty with | Tvar name when get_level ty = generic_level -> let t = newty (Tunivar name) in - For_copy.redirect_desc scope ty (Tsubst (t, None)); + For_copy.redirect_desc copy_scope ty (Tsubst (t, None)); Some t | _ -> None in (* need to expand twice? cf. Ctype.unify2 *) let vars = List.map (expand_head env) vars in let vars = List.map (expand_head env) vars in - For_copy.with_scope (fun scope -> - let vars' = List.filter_map (subst_univar scope) vars in - let ty = copy scope ty in + For_copy.with_scope (fun copy_scope -> + let vars' = List.filter_map (subst_univar copy_scope) vars in + let ty = copy copy_scope ty in let ty = newty2 ~level:(get_level ty) (Tpoly(ty, vars')) in let complete = List.length vars = List.length vars' in ty, complete @@ -2098,28 +2208,26 @@ let deep_occur t0 ty = with Occur -> unmark_type ty; true -let gadt_equations_level = ref None -let get_gadt_equations_level () = - match !gadt_equations_level with - | None -> assert false - | Some x -> x - - -(* a local constraint can be added only if the rhs +(* A local constraint can be added only if the rhs of the constraint does not contain any Tvars. - They need to be removed using this function *) -let reify env t = - let fresh_constr_scope = get_gadt_equations_level () in + They need to be removed using this function. + This function is called only in [Pattern] mode. *) +let reify uenv t = + let fresh_constr_scope = get_equations_scope uenv in let create_fresh_constr lev name = let name = match name with Some s -> "$'"^s | _ -> "$" in - let decl = new_local_type () in + let decl = new_local_type Definition in + let env = get_env uenv in + let new_name = + (* unique names are needed only for error messages *) + if in_counterexample uenv then name else get_new_abstract_name env name + in let (id, new_env) = - Env.enter_type (get_new_abstract_name name) decl !env - ~scope:fresh_constr_scope in + Env.enter_type new_name decl env ~scope:fresh_constr_scope in let path = Path.Pident id in - let t = newty2 ~level:lev (Tconstr (path,[],ref Mnil)) in - env := new_env; + let t = newty2 ~level:lev (Tconstr (path,[],ref Mnil)) in + set_env uenv new_env; path, t in let visited = ref TypeSet.empty in @@ -2151,21 +2259,16 @@ let reify env t = | _ -> assert false end; iter_row iterator r - | Tconstr (p, _, _) when is_object_type p -> - iter_type_expr iterator (full_expand ~may_forget_scope:false !env ty) | _ -> iter_type_expr iterator ty end in iterator t -let is_newtype env p = - try - let decl = Env.find_type p env in - decl.type_expansion_scope <> Btype.lowest_level && - decl.type_kind = Type_abstract && - decl.type_private = Public - with Not_found -> false +let find_expansion_scope env path = + match Env.find_type path env with + | { type_manifest = None ; _ } | exception Not_found -> generic_level + | decl -> decl.type_expansion_scope let non_aliasable p decl = (* in_pervasives p || (subsumed by in_current_module) *) @@ -2174,7 +2277,7 @@ let non_aliasable p decl = let is_instantiable env p = try let decl = Env.find_type p env in - decl.type_kind = Type_abstract && + type_kind_is_abstract decl && decl.type_private = Public && decl.type_arity = 0 && decl.type_manifest = None && @@ -2182,7 +2285,6 @@ let is_instantiable env p = with Not_found -> false -(* PR#7113: -safe-string should be a global property *) let compatible_paths p1 p2 = let open Predef in Path.same p1 p2 || @@ -2358,9 +2460,9 @@ and mcomp_type_decl type_pairs env p1 p2 tl1 tl2 = mcomp_variant_description type_pairs env v1 v2 | Type_open, Type_open -> mcomp_list type_pairs env tl1 tl2 - | Type_abstract, Type_abstract -> () - | Type_abstract, _ when not (non_aliasable p1 decl)-> () - | _, Type_abstract when not (non_aliasable p2 decl') -> () + | Type_abstract _, Type_abstract _ -> () + | Type_abstract _, _ when not (non_aliasable p1 decl)-> () + | _, Type_abstract _ when not (non_aliasable p2 decl') -> () | _ -> raise Incompatible with Not_found -> () @@ -2424,33 +2526,32 @@ let find_lowest_level ty = end in find ty; unmark_type ty; !lowest -let find_expansion_scope env path = - (Env.find_type path env).type_expansion_scope - -let add_gadt_equation env source destination = +(* This function can be called only in [Pattern] mode. *) +let add_gadt_equation uenv source destination = (* Format.eprintf "@[add_gadt_equation %s %a@]@." (Path.name source) !Btype.print_raw destination; *) - if has_free_univars !env destination then - occur_univar ~inj_only:true !env destination - else if local_non_recursive_abbrev !env source destination then begin + let env = get_env uenv in + if has_free_univars env destination then + occur_univar ~inj_only:true env destination + else if local_non_recursive_abbrev uenv source destination then begin let destination = duplicate_type destination in let expansion_scope = - Int.max (Path.scope source) (get_gadt_equations_level ()) + Int.max (Path.scope source) (get_equations_scope uenv) + in + let type_origin = + match Env.find_type source env with + | decl -> type_origin decl + | exception Not_found -> assert false in let decl = - new_local_type ~manifest_and_scope:(destination, expansion_scope) () in - env := Env.add_local_type source decl !env; + new_local_type + ~manifest_and_scope:(destination, expansion_scope) + type_origin + in + set_env uenv (Env.add_local_constraint source decl env); cleanup_abbrev () end -let unify_eq_set = TypePairs.create 11 - -let order_type_pair t1 t2 = - if get_id t1 <= get_id t2 then (t1, t2) else (t2, t1) - -let add_type_equality t1 t2 = - TypePairs.add unify_eq_set (order_type_pair t1 t2) - let eq_package_path env p1 p2 = Path.same p1 p2 || Path.same (normalize_package_path env p1) (normalize_package_path env p2) @@ -2499,7 +2600,7 @@ let complete_type_list ?(allow_absent=false) env fl1 lv2 mty2 fl2 = | (n, _) :: nl, _ -> let lid = concat_longident (Longident.Lident "Pkg") n in match Env.find_type_by_name lid env' with - | (_, {type_arity = 0; type_kind = Type_abstract; + | (_, {type_arity = 0; type_kind = Type_abstract _; type_private = Public; type_manifest = Some t2}) -> begin match nondep_instance env' lv2 id2 t2 with | t -> (n, t) :: complete nl fl2 @@ -2509,7 +2610,7 @@ let complete_type_list ?(allow_absent=false) env fl1 lv2 mty2 fl2 = else raise Exit end - | (_, {type_arity = 0; type_kind = Type_abstract; + | (_, {type_arity = 0; type_kind = Type_abstract _; type_private = Public; type_manifest = None}) when allow_absent -> complete nl fl2 @@ -2532,18 +2633,15 @@ let unify_package env unify_list lv1 p1 fl1 lv2 p2 fl2 = (* force unification in Reither when one side has a non-conjunctive type *) +(* Code smell: this could also be put in unification_environment. + Only modified by expand_head_rigid, but the corresponding unification + environment is built in subst. *) let rigid_variants = ref false -let unify_eq t1 t2 = - eq_type t1 t2 || - match !umode with - | Expression -> false - | Pattern -> - TypePairs.mem unify_eq_set (order_type_pair t1 t2) - -let unify1_var env t1 t2 = +let unify1_var uenv t1 t2 = assert (is_Tvar t1); - occur_for Unify env t1 t2; + occur_for Unify uenv t1 t2; + let env = get_env uenv in match occur_univar_for Unify env t2 with | () -> begin @@ -2555,27 +2653,20 @@ let unify1_var env t1 t2 = end; link_type t1 t2; true - | exception Unify_trace _ when !umode = Pattern -> + | exception Unify_trace _ when in_pattern_mode uenv -> false -(* Can only be called when generate_equations is true *) -let record_equation t1 t2 = - match !equations_generation with - | Forbidden -> assert false - | Allowed { equated_types } -> - TypePairs.add equated_types (t1, t2) - (* Called from unify3 *) -let unify3_var env t1' t2 t2' = - occur_for Unify !env t1' t2; - match occur_univar_for Unify !env t2 with +let unify3_var uenv t1' t2 t2' = + occur_for Unify uenv t1' t2; + match occur_univar_for Unify (get_env uenv) t2 with | () -> link_type t1' t2 - | exception Unify_trace _ when !umode = Pattern -> - reify env t1'; - reify env t2'; - if can_generate_equations () then begin - occur_univar ~inj_only:true !env t2'; - record_equation t1' t2'; + | exception Unify_trace _ when in_pattern_mode uenv -> + reify uenv t1'; + reify uenv t2'; + if can_generate_equations uenv then begin + occur_univar ~inj_only:true (get_env uenv) t2'; + record_equation uenv t1' t2'; end (* @@ -2602,71 +2693,84 @@ let unify3_var env t1' t2 t2' = information is indeed lost, but it probably does not worth it. *) -let rec unify (env:Env.t ref) t1 t2 = +let rec unify uenv t1 t2 = (* First step: special cases (optimizations) *) - if unify_eq t1 t2 then () else - let reset_tracing = check_trace_gadt_instances !env in + if unify_eq uenv t1 t2 then () else + let reset_tracing = check_trace_gadt_instances (get_env uenv) in try type_changed := true; begin match (get_desc t1, get_desc t2) with (Tvar _, Tconstr _) when deep_occur t1 t2 -> - unify2 env t1 t2 + unify2 uenv t1 t2 | (Tconstr _, Tvar _) when deep_occur t2 t1 -> - unify2 env t1 t2 + unify2 uenv t1 t2 | (Tvar _, _) -> - if unify1_var !env t1 t2 then () else unify2 env t1 t2 + if unify1_var uenv t1 t2 then () else unify2 uenv t1 t2 | (_, Tvar _) -> - if unify1_var !env t2 t1 then () else unify2 env t1 t2 + if unify1_var uenv t2 t1 then () else unify2 uenv t1 t2 | (Tunivar _, Tunivar _) -> unify_univar_for Unify t1 t2 !univar_pairs; - update_level_for Unify !env (get_level t1) t2; + update_level_for Unify (get_env uenv) (get_level t1) t2; update_scope_for Unify (get_scope t1) t2; link_type t1 t2 | (Tconstr (p1, [], a1), Tconstr (p2, [], a2)) - when Path.same p1 p2 (* && actual_mode !env = Old *) + when Path.same p1 p2 (* This optimization assumes that t1 does not expand to t2 (and conversely), so we fall back to the general case when any of the types has a cached expansion. *) && not (has_cached_expansion p1 !a1 || has_cached_expansion p2 !a2) -> - update_level_for Unify !env (get_level t1) t2; + update_level_for Unify (get_env uenv) (get_level t1) t2; update_scope_for Unify (get_scope t1) t2; link_type t1 t2 - | (Tconstr (p1, [], _), Tconstr (p2, [], _)) - when Env.has_local_constraints !env - && is_newtype !env p1 && is_newtype !env p2 -> - (* Do not use local constraints more than necessary *) - begin try - if find_expansion_scope !env p1 > find_expansion_scope !env p2 then - unify env t1 (try_expand_safe !env t2) - else - unify env (try_expand_safe !env t1) t2 - with Cannot_expand -> - unify2 env t1 t2 - end + | (Tconstr _, Tconstr _) when Env.has_local_constraints (get_env uenv) -> + unify2_rec uenv t1 t1 t2 t2 | _ -> - unify2 env t1 t2 + unify2 uenv t1 t2 end; reset_trace_gadt_instances reset_tracing; with Unify_trace trace -> reset_trace_gadt_instances reset_tracing; raise_trace_for Unify (Diff {got = t1; expected = t2} :: trace) -and unify2 env t1 t2 = +and unify2 uenv t1 t2 = unify2_expand uenv t1 t1 t2 t2 + +and unify2_rec uenv t10 t1 t20 t2 = + if unify_eq uenv t1 t2 then () else + try match (get_desc t1, get_desc t2) with + | (Tconstr (p1, tl1, a1), Tconstr (p2, tl2, a2)) -> + if Path.same p1 p2 && tl1 = [] && tl2 = [] + && not (has_cached_expansion p1 !a1 || has_cached_expansion p2 !a2) + then begin + update_level_for Unify (get_env uenv) (get_level t1) t2; + update_scope_for Unify (get_scope t1) t2; + link_type t1 t2 + end else + let env = get_env uenv in + if find_expansion_scope env p1 > find_expansion_scope env p2 + then unify2_rec uenv t10 t1 t20 (try_expand_safe env t2) + else unify2_rec uenv t10 (try_expand_safe env t1) t20 t2 + | _ -> + raise Cannot_expand + with Cannot_expand -> + unify2_expand uenv t10 t1 t20 t2 + +and unify2_expand uenv t1 t1' t2 t2' = (* Second step: expansion of abbreviations *) (* Expansion may change the representative of the types. *) - ignore (expand_head_unif !env t1); - ignore (expand_head_unif !env t2); - let t1' = expand_head_unif !env t1 in - let t2' = expand_head_unif !env t2 in + let env = get_env uenv in + ignore (expand_head_unif env t1'); + ignore (expand_head_unif env t2'); + let t1' = expand_head_unif env t1' in + let t2' = expand_head_unif env t2' in let lv = Int.min (get_level t1') (get_level t2') in let scope = Int.max (get_scope t1') (get_scope t2') in - update_level_for Unify !env lv t2; - update_level_for Unify !env lv t1; + update_level_for Unify env lv t2; + update_level_for Unify env lv t1; update_scope_for Unify scope t2; update_scope_for Unify scope t1; - if unify_eq t1' t2' then () else + if unify_eq uenv t1' t2' then () else let t1, t2 = if !Clflags.principal @@ -2677,13 +2781,13 @@ and unify2 env t1 t2 = (match get_desc t2 with Tconstr (_, [], _) -> t2' | _ -> t2) else (t1, t2) in - if unify_eq t1 t1' || not (unify_eq t2 t2') then - unify3 env t1 t1' t2 t2' + if unify_eq uenv t1 t1' || not (unify_eq uenv t2 t2') then + unify3 uenv t1 t1' t2 t2' else - try unify3 env t2 t2' t1 t1' with Unify_trace trace -> + try unify3 uenv t2 t2' t1 t1' with Unify_trace trace -> raise_trace_for Unify (swap_trace trace) -and unify3 env t1 t1' t2 t2' = +and unify3 uenv t1 t1' t2 t2' = (* Third step: truly unification *) (* Assumes either [t1 == t1'] or [t2 != t2'] *) let tt1' = Transient_expr.repr t1' in @@ -2696,25 +2800,24 @@ and unify3 env t1 t1' t2 t2' = unify_univar_for Unify t1' t2' !univar_pairs; link_type t1' t2' | (Tvar _, _) -> - unify3_var env t1' t2 t2' + unify3_var uenv t1' t2 t2' | (_, Tvar _) -> - unify3_var env t2' t1 t1' + unify3_var uenv t2' t1 t1' | (Tfield _, Tfield _) -> (* special case for GADTs *) - unify_fields env t1' t2' + unify_fields uenv t1' t2' | _ -> - begin match !umode with - | Expression -> - occur_for Unify !env t1' t2; - link_type t1' t2 - | Pattern -> - add_type_equality t1' t2' + if in_pattern_mode uenv then + add_type_equality uenv t1' t2' + else begin + occur_for Unify uenv t1' t2; + link_type t1' t2 end; try begin match (d1, d2) with (Tarrow (l1, t1, u1, c1), Tarrow (l2, t2, u2, c2)) when l1 = l2 || - (!Clflags.classic || !umode = Pattern) && + (!Clflags.classic || in_pattern_mode uenv) && not (is_optional l1 || is_optional l2) -> - unify env t1 t2; unify env u1 u2; + unify uenv t1 t2; unify uenv u1 u2; begin match is_commu_ok c1, is_commu_ok c2 with | false, true -> set_commu_ok c1 | true, false -> set_commu_ok c2 @@ -2722,67 +2825,67 @@ and unify3 env t1 t1' t2 t2' = | true, true -> () end | (Ttuple tl1, Ttuple tl2) -> - unify_list env tl1 tl2 + unify_list uenv tl1 tl2 | (Tconstr (p1, tl1, _), Tconstr (p2, tl2, _)) when Path.same p1 p2 -> - if !umode = Expression || !equations_generation = Forbidden then - unify_list env tl1 tl2 - else if !assume_injective then - set_mode_pattern ~generate:!equations_generation ~injective:false - ~allow_recursive:!allow_recursive_equation - (fun () -> unify_list env tl1 tl2) + if not (can_generate_equations uenv) then + unify_list uenv tl1 tl2 + else if can_assume_injective uenv then + without_assume_injective uenv (fun uenv -> unify_list uenv tl1 tl2) else if in_current_module p1 (* || in_pervasives p1 *) - || List.exists (expands_to_datatype !env) [t1'; t1; t2] + || List.exists (expands_to_datatype (get_env uenv)) [t1'; t1; t2] then - unify_list env tl1 tl2 + unify_list uenv tl1 tl2 else let inj = try List.map Variance.(mem Inj) - (Env.find_type p1 !env).type_variance + (Env.find_type p1 (get_env uenv)).type_variance with Not_found -> List.map (fun _ -> false) tl1 in List.iter2 (fun i (t1, t2) -> - if i then unify env t1 t2 else - set_mode_pattern ~generate:Forbidden ~injective:false - ~allow_recursive:!allow_recursive_equation - begin fun () -> + if i then unify uenv t1 t2 else + without_generating_equations uenv + begin fun uenv -> let snap = snapshot () in - try unify env t1 t2 with Unify_trace _ -> + try unify uenv t1 t2 with Unify_trace _ -> backtrack snap; - reify env t1; - reify env t2 + reify uenv t1; + reify uenv t2 end) inj (List.combine tl1 tl2) | (Tconstr (path,[],_), Tconstr (path',[],_)) - when is_instantiable !env path && is_instantiable !env path' - && can_generate_equations () -> + when let env = get_env uenv in + is_instantiable env path && is_instantiable env path' + && can_generate_equations uenv -> let source, destination = if Path.scope path > Path.scope path' then path , t2' else path', t1' in - record_equation t1' t2'; - add_gadt_equation env source destination + record_equation uenv t1' t2'; + add_gadt_equation uenv source destination | (Tconstr (path,[],_), _) - when is_instantiable !env path && can_generate_equations () -> - reify env t2'; - record_equation t1' t2'; - add_gadt_equation env path t2' + when is_instantiable (get_env uenv) path + && can_generate_equations uenv -> + reify uenv t2'; + record_equation uenv t1' t2'; + add_gadt_equation uenv path t2' | (_, Tconstr (path,[],_)) - when is_instantiable !env path && can_generate_equations () -> - reify env t1'; - record_equation t1' t2'; - add_gadt_equation env path t1' - | (Tconstr (_,_,_), _) | (_, Tconstr (_,_,_)) when !umode = Pattern -> - reify env t1'; - reify env t2'; - if can_generate_equations () then ( - mcomp_for Unify !env t1' t2'; - record_equation t1' t2' + when is_instantiable (get_env uenv) path + && can_generate_equations uenv -> + reify uenv t1'; + record_equation uenv t1' t2'; + add_gadt_equation uenv path t1' + | (Tconstr (_,_,_), _) | (_, Tconstr (_,_,_)) when in_pattern_mode uenv -> + reify uenv t1'; + reify uenv t2'; + if can_generate_equations uenv then ( + mcomp_for Unify (get_env uenv) t1' t2'; + record_equation uenv t1' t2' ) | (Tobject (fi1, nm1), Tobject (fi2, _)) -> - unify_fields env fi1 fi2; + unify_fields uenv fi1 fi2; (* Type [t2'] may have been instantiated by [unify_fields] *) (* XXX One should do some kind of unification... *) begin match get_desc t2' with @@ -2793,26 +2896,26 @@ and unify3 env t1 t1' t2 t2' = | _ -> () end | (Tvariant row1, Tvariant row2) -> - if !umode = Expression then - unify_row env row1 row2 + if not (in_pattern_mode uenv) then + unify_row uenv row1 row2 else begin let snap = snapshot () in - try unify_row env row1 row2 + try unify_row uenv row1 row2 with Unify_trace _ -> backtrack snap; - reify env t1'; - reify env t2'; - if can_generate_equations () then ( - mcomp_for Unify !env t1' t2'; - record_equation t1' t2' + reify uenv t1'; + reify uenv t2'; + if can_generate_equations uenv then ( + mcomp_for Unify (get_env uenv) t1' t2'; + record_equation uenv t1' t2' ) end | (Tfield(f,kind,_,rem), Tnil) | (Tnil, Tfield(f,kind,_,rem)) -> begin match field_kind_repr kind with Fprivate when f <> dummy_method -> link_kind ~inside:kind field_absent; - if d2 = Tnil then unify env rem t2' - else unify env (newgenty Tnil) rem + if d2 = Tnil then unify uenv rem t2' + else unify uenv (newgenty Tnil) rem | _ -> if f = dummy_method then raise_for Unify (Obj Self_cannot_be_closed) @@ -2824,16 +2927,17 @@ and unify3 env t1 t1' t2 t2' = | (Tnil, Tnil) -> () | (Tpoly (t1, []), Tpoly (t2, [])) -> - unify env t1 t2 + unify uenv t1 t2 | (Tpoly (t1, tl1), Tpoly (t2, tl2)) -> - enter_poly_for Unify !env univar_pairs t1 tl1 t2 tl2 (unify env) + enter_poly_for Unify (get_env uenv) univar_pairs t1 tl1 t2 tl2 + (unify uenv) | (Tpackage (p1, fl1), Tpackage (p2, fl2)) -> begin try - unify_package !env (unify_list env) + unify_package (get_env uenv) (unify_list uenv) (get_level t1) p1 fl1 (get_level t2) p2 fl2 with Not_found -> - if !umode = Expression then raise_unexplained_for Unify; - List.iter (fun (_n, ty) -> reify env ty) (fl1 @ fl2); + if not (in_pattern_mode uenv) then raise_unexplained_for Unify; + List.iter (fun (_n, ty) -> reify uenv ty) (fl1 @ fl2); (* if !generate_equations then List.iter2 (mcomp !env) tl1 tl2 *) end | (Tnil, Tconstr _ ) -> @@ -2848,7 +2952,7 @@ and unify3 env t1 t1' t2 t2' = match get_desc t2 with Tconstr (p, tl, abbrev) -> forget_abbrev abbrev p; - let t2'' = expand_head_unif !env t2 in + let t2'' = expand_head_unif (get_env uenv) t2 in if not (closed_parameterized_type tl t2'') then link_type t2 t2' | _ -> @@ -2883,7 +2987,7 @@ and make_rowvar level use1 rest1 use2 rest2 = if use1 then rest1 else if use2 then rest2 else newty2 ~level (Tvar name) -and unify_fields env ty1 ty2 = (* Optimization *) +and unify_fields uenv ty1 ty2 = (* Optimization *) let (fields1, rest1) = flatten_fields ty1 and (fields2, rest2) = flatten_fields ty2 in let (pairs, miss1, miss2) = associate_fields fields1 fields2 in @@ -2892,17 +2996,18 @@ and unify_fields env ty1 ty2 = (* Optimization *) let tr1 = Transient_expr.repr rest1 and tr2 = Transient_expr.repr rest2 in let d1 = tr1.desc and d2 = tr2.desc in try - unify env (build_fields l1 miss1 va) rest2; - unify env rest1 (build_fields l2 miss2 va); + unify uenv (build_fields l1 miss1 va) rest2; + unify uenv rest1 (build_fields l2 miss2 va); List.iter (fun (name, k1, t1, k2, t2) -> unify_kind k1 k2; try - if !trace_gadt_instances then begin - update_level_for Unify !env (get_level va) t1; + if !trace_gadt_instances && not (in_subst_mode uenv) then begin + (* in_subst_mode: see PR#11771 *) + update_level_for Unify (get_env uenv) (get_level va) t1; update_scope_for Unify (get_scope va) t1 end; - unify env t1 t2 + unify uenv t1 t2 with Unify_trace trace -> raise_trace_for Unify (incompatible_fields ~name ~got:t1 ~expected:t2 :: trace) @@ -2920,12 +3025,12 @@ and unify_kind k1 k2 = | (Fpublic, Fpublic) -> () | _ -> assert false -and unify_row env row1 row2 = +and unify_row uenv row1 row2 = let Row {fields = row1_fields; more = rm1; closed = row1_closed; name = row1_name} = row_repr row1 in let Row {fields = row2_fields; more = rm2; closed = row2_closed; name = row2_name} = row_repr row2 in - if unify_eq rm1 rm2 then () else + if unify_eq uenv rm1 rm2 then () else let r1, r2, pairs = merge_row_fields row1_fields row2_fields in if r1 <> [] && r2 <> [] then begin let ht = Hashtbl.create (List.length r1) in @@ -2990,17 +3095,19 @@ and unify_row env row1 row2 = (* The following test is not principal... should rather use Tnil *) let rm = row_more row in (*if !trace_gadt_instances && rm.desc = Tnil then () else*) - if !trace_gadt_instances then - update_level_for Unify !env (get_level rm) (newgenty (Tvariant row)); + if !trace_gadt_instances && not (in_subst_mode uenv) then + (* in_subst_mode: see PR#11771 *) + update_level_for Unify (get_env uenv) (get_level rm) + (newgenty (Tvariant row)); if has_fixed_explanation row then if eq_type more rm then () else - if is_Tvar rm then link_type rm more else unify env rm more + if is_Tvar rm then link_type rm more else unify uenv rm more else let ty = newgenty (Tvariant (create_row ~fields:rest ~more ~closed ~fixed ~name)) in - update_level_for Unify !env (get_level rm) ty; + update_level_for Unify (get_env uenv) (get_level rm) ty; update_scope_for Unify (get_scope rm) ty; link_type rm ty in @@ -3011,7 +3118,7 @@ and unify_row env row1 row2 = set_more First row1 r2; List.iter (fun (l,f1,f2) -> - try unify_row_field env fixed1 fixed2 rm1 rm2 l f1 f2 + try unify_row_field uenv fixed1 fixed2 rm1 rm2 l f1 f2 with Unify_trace trace -> raise_trace_for Unify (Variant (Incompatible_types_for l) :: trace) ) @@ -3026,7 +3133,7 @@ and unify_row env row1 row2 = raise exn end -and unify_row_field env fixed1 fixed2 rm1 rm2 l f1 f2 = +and unify_row_field uenv fixed1 fixed2 rm1 rm2 l f1 f2 = let if_not_fixed (pos,fixed) f = match fixed with | None -> f () @@ -3039,7 +3146,7 @@ and unify_row_field env fixed1 fixed2 rm1 rm2 l f1 f2 = | _ -> true in if f1 == f2 then () else match row_field_repr f1, row_field_repr f2 with - Rpresent(Some t1), Rpresent(Some t2) -> unify env t1 t2 + Rpresent(Some t1), Rpresent(Some t2) -> unify uenv t1 t2 | Rpresent None, Rpresent None -> () | Reither(c1, tl1, m1), Reither(c2, tl2, m2) -> if eq_row_field_ext f1 f2 then () else @@ -3049,7 +3156,7 @@ and unify_row_field env fixed1 fixed2 rm1 rm2 l f1 f2 = (* PR#7496 *) let f = rf_either [] ~no_arg ~matched in link_row_field_ext ~inside:f1 f; link_row_field_ext ~inside:f2 f; - List.iter2 (unify env) tl1 tl2 + List.iter2 (unify uenv) tl1 tl2 end else let redo = (m1 || m2 || either_fixed || @@ -3058,29 +3165,31 @@ and unify_row_field env fixed1 fixed2 rm1 rm2 l f1 f2 = | t1 :: tl -> if no_arg then raise_unexplained_for Unify; Types.changed_row_field_exts [f1;f2] (fun () -> - List.iter (unify env t1) tl + List.iter (unify uenv t1) tl ) end in - if redo then unify_row_field env fixed1 fixed2 rm1 rm2 l f1 f2 else + if redo then unify_row_field uenv fixed1 fixed2 rm1 rm2 l f1 f2 else let remq tl = List.filter (fun ty -> not (List.exists (eq_type ty) tl)) in let tl1' = remq tl2 tl1 and tl2' = remq tl1 tl2 in (* PR#6744 *) - let (tlu1,tl1') = List.partition (has_free_univars !env) tl1' - and (tlu2,tl2') = List.partition (has_free_univars !env) tl2' in + let env = get_env uenv in + let (tlu1,tl1') = List.partition (has_free_univars env) tl1' + and (tlu2,tl2') = List.partition (has_free_univars env) tl2' in begin match tlu1, tlu2 with [], [] -> () | (tu1::tlu1), _ :: _ -> (* Attempt to merge all the types containing univars *) - List.iter (unify env tu1) (tlu1@tlu2) + List.iter (unify uenv tu1) (tlu1@tlu2) | (tu::_, []) | ([], tu::_) -> - occur_univar_for Unify !env tu + occur_univar_for Unify env tu end; (* Is this handling of levels really principal? *) let update_levels rm = + let env = get_env uenv in List.iter (fun ty -> - update_level_for Unify !env (get_level rm) ty; + update_level_for Unify env (get_level rm) ty; update_scope_for Unify (get_scope rm) ty) in update_levels rm2 tl1'; @@ -3097,62 +3206,71 @@ and unify_row_field env fixed1 fixed2 rm1 rm2 l f1 f2 = if_not_fixed first (fun () -> let s = snapshot () in link_row_field_ext ~inside:f1 f2; - update_level_for Unify !env (get_level rm1) t2; + update_level_for Unify (get_env uenv) (get_level rm1) t2; update_scope_for Unify (get_scope rm1) t2; - (try List.iter (fun t1 -> unify env t1 t2) tl + (try List.iter (fun t1 -> unify uenv t1 t2) tl with exn -> undo_first_change_after s; raise exn) ) | Rpresent(Some t1), Reither(false, tl, _) -> if_not_fixed second (fun () -> let s = snapshot () in link_row_field_ext ~inside:f2 f1; - update_level_for Unify !env (get_level rm2) t1; + update_level_for Unify (get_env uenv) (get_level rm2) t1; update_scope_for Unify (get_scope rm2) t1; - (try List.iter (unify env t1) tl + (try List.iter (unify uenv t1) tl with exn -> undo_first_change_after s; raise exn) ) | Reither(true, [], _), Rpresent None -> if_not_fixed first (fun () -> link_row_field_ext ~inside:f1 f2) | Rpresent None, Reither(true, [], _) -> if_not_fixed second (fun () -> link_row_field_ext ~inside:f2 f1) - | _ -> raise_unexplained_for Unify - -let unify env ty1 ty2 = + | Rabsent, (Rpresent _ | Reither(_,_,true)) -> + raise_trace_for Unify [Variant(No_tags(First, [l,f1]))] + | (Rpresent _ | Reither (_,_,true)), Rabsent -> + raise_trace_for Unify [Variant(No_tags(Second, [l,f2]))] + | (Rpresent (Some _) | Reither(false,_,_)), + (Rpresent None | Reither(true,_,_)) + | (Rpresent None | Reither(true,_,_)), + (Rpresent (Some _) | Reither(false,_,_)) -> + (* constructor arity mismatch: 0 <> 1 *) + raise_unexplained_for Unify + | Reither(true, _ :: _, _ ), Rpresent _ + | Rpresent _ , Reither(true, _ :: _, _ ) -> + (* inconsistent conjunction on a non-absent field *) + raise_unexplained_for Unify + +let unify uenv ty1 ty2 = let snap = Btype.snapshot () in try - unify env ty1 ty2 + unify uenv ty1 ty2 with Unify_trace trace -> undo_compress snap; - raise (Unify (expand_to_unification_error !env trace)) + raise (Unify (expand_to_unification_error (get_env uenv) trace)) -let unify_gadt ~equations_level:lev ~allow_recursive (env:Env.t ref) ty1 ty2 = - try - univar_pairs := []; - gadt_equations_level := Some lev; - let equated_types = TypePairs.create 0 in - set_mode_pattern - ~generate:(Allowed { equated_types }) - ~injective:true - ~allow_recursive - (fun () -> unify env ty1 ty2); - gadt_equations_level := None; - TypePairs.clear unify_eq_set; - equated_types - with e -> - gadt_equations_level := None; - TypePairs.clear unify_eq_set; - raise e - -let unify_var env t1 t2 = +let unify_gadt (penv : Pattern_env.t) ty1 ty2 = + univar_pairs := []; + let equated_types = TypePairs.create 0 in + let equations_generation = Allowed { equated_types } in + let uenv = Pattern + { penv; + equations_generation; + assume_injective = true; + unify_eq_set = TypePairs.create 11; } + in + unify uenv ty1 ty2; + equated_types + +let unify_var uenv t1 t2 = if eq_type t1 t2 then () else match get_desc t1, get_desc t2 with Tvar _, Tconstr _ when deep_occur t1 t2 -> - unify (ref env) t1 t2 + unify uenv t1 t2 | Tvar _, _ -> + let env = get_env uenv in let reset_tracing = check_trace_gadt_instances env in begin try - occur_for Unify env t1 t2; + occur_for Unify uenv t1 t2; update_level_for Unify env (get_level t1) t2; update_scope_for Unify (get_scope t1) t2; link_type t1 t2; @@ -3164,17 +3282,23 @@ let unify_var env t1 t2 = (Diff { got = t1; expected = t2 } :: trace))) end | _ -> - unify (ref env) t1 t2 + unify uenv t1 t2 let _ = unify_var' := unify_var +(* the final versions of unification functions *) +let unify_var env ty1 ty2 = + unify_var (Expression {env; in_subst = false}) ty1 ty2 + let unify_pairs env ty1 ty2 pairs = univar_pairs := pairs; - unify env ty1 ty2 + unify (Expression {env; in_subst = false}) ty1 ty2 let unify env ty1 ty2 = - unify_pairs (ref env) ty1 ty2 [] + unify_pairs env ty1 ty2 [] +(* Lower the level of a type to the current level *) +let enforce_current_level env ty = unify_var env (newvar ()) ty (**** Special cases of unification ****) @@ -3632,7 +3756,7 @@ let rec moregen inst_nongen type_pairs env t1 t2 = (Tvar _, _) when may_instantiate inst_nongen t1 -> moregen_occur env (get_level t1) t2; update_scope_for Moregen (get_scope t1) t2; - occur_for Moregen env t1 t2; + occur_for Moregen (Expression {env; in_subst = false}) t1 t2; link_type t1 t2 | (Tconstr (p1, [], _), Tconstr (p2, [], _)) when Path.same p1 p2 -> () @@ -4201,9 +4325,9 @@ let rec equal_private env params1 ty1 params2 ty2 = type class_match_failure = CM_Virtual_class | CM_Parameter_arity_mismatch of int * int - | CM_Type_parameter_mismatch of Env.t * equality_error + | CM_Type_parameter_mismatch of int * Env.t * equality_error | CM_Class_type_mismatch of Env.t * class_type * class_type - | CM_Parameter_mismatch of Env.t * moregen_error + | CM_Parameter_mismatch of int * Env.t * moregen_error | CM_Val_type_mismatch of string * Env.t * comparison_error | CM_Meth_type_mismatch of string * Env.t * comparison_error | CM_Non_mutable_value of string @@ -4271,20 +4395,24 @@ let match_class_sig_shape ~strict sign1 sign2 = else err) sign1.csig_vars errors -let rec moregen_clty trace type_pairs env cty1 cty2 = +(* [arrow_index] is the number of [Cty_arrow] + constructors we've seen so far. *) +let rec moregen_clty ~arrow_index trace type_pairs env cty1 cty2 = try match cty1, cty2 with | Cty_constr (_, _, cty1), _ -> - moregen_clty true type_pairs env cty1 cty2 + moregen_clty ~arrow_index true type_pairs env cty1 cty2 | _, Cty_constr (_, _, cty2) -> - moregen_clty true type_pairs env cty1 cty2 + moregen_clty ~arrow_index true type_pairs env cty1 cty2 | Cty_arrow (l1, ty1, cty1'), Cty_arrow (l2, ty2, cty2') when l1 = l2 -> + let arrow_index = arrow_index + 1 in begin try moregen true type_pairs env ty1 ty2 with Moregen_trace trace -> raise (Failure [ - CM_Parameter_mismatch (env, expand_to_moregen_error env trace)]) + CM_Parameter_mismatch + (arrow_index, env, expand_to_moregen_error env trace)]) end; - moregen_clty false type_pairs env cty1' cty2' + moregen_clty ~arrow_index false type_pairs env cty1' cty2' | Cty_signature sign1, Cty_signature sign2 -> Meths.iter (fun lab (_, _, ty) -> @@ -4328,6 +4456,9 @@ let rec moregen_clty trace type_pairs env cty1 cty2 = Failure error when trace || error = [] -> raise (Failure (CM_Class_type_mismatch (env, cty1, cty2)::error)) +let moregen_clty trace type_pairs env cty1 cty2 = + moregen_clty ~arrow_index:0 trace type_pairs env cty1 cty2 + let match_class_types ?(trace=true) env pat_sch subj_sch = let sign1 = signature_of_class_type pat_sch in let sign2 = signature_of_class_type subj_sch in @@ -4442,11 +4573,11 @@ let match_class_declarations env patt_params patt_type subj_params subj_type = let ls = List.length subj_params in if lp <> ls then raise (Failure [CM_Parameter_arity_mismatch (lp, ls)]); - List.iter2 (fun p s -> + Std.List.iteri2 ~f:(fun n p s -> try eqtype true type_pairs subst env p s with Equality_trace trace -> raise (Failure [CM_Type_parameter_mismatch - (env, expand_to_equality_error env trace !subst)])) + (n+1, env, expand_to_equality_error env trace !subst)])) patt_params subj_params; (* old code: equal_clty false type_pairs subst env patt_type subj_type; *) equal_clsig false type_pairs subst env sign1 sign2; @@ -4793,7 +4924,7 @@ let rec subtype_rec env trace t1 t2 cstrs = | (Tpoly (u1, []), Tpoly (u2, [])) -> subtype_rec env trace u1 u2 cstrs | (Tpoly (u1, tl1), Tpoly (u2, [])) -> - let _, u1' = instance_poly false tl1 u1 in + let _, u1' = instance_poly ~fixed:false tl1 u1 in subtype_rec env trace u1' u2 cstrs | (Tpoly (u1, tl1), Tpoly (u2,tl2)) -> begin try @@ -4953,7 +5084,7 @@ let subtype env ty1 ty2 = function () -> List.iter (function (trace0, t1, t2, pairs) -> - try unify_pairs (ref env) t1 t2 pairs with Unify {trace} -> + try unify_pairs env t1 t2 pairs with Unify {trace} -> subtype_error ~env ~trace:trace0 ~unification_trace:(List.tl trace)) (List.rev cstrs) @@ -4999,69 +5130,108 @@ let rec arity ty = | _ -> 0 (* Check for non-generalizable type variables *) -exception Nongen -let visited = ref TypeSet.empty - -let rec nongen_schema_rec env ty = - if TypeSet.mem ty !visited then () else begin - visited := TypeSet.add ty !visited; - match get_desc ty with - Tvar _ when get_level ty <> generic_level -> - raise Nongen - | Tconstr _ -> - let old = !visited in - begin try iter_type_expr (nongen_schema_rec env) ty - with Nongen -> try - visited := old; - nongen_schema_rec env (try_expand_head try_expand_safe env ty) - with Cannot_expand -> - raise Nongen - end - | Tfield(_, kind, t1, t2) -> - if field_kind_repr kind = Fpublic then - nongen_schema_rec env t1; - nongen_schema_rec env t2 - | Tvariant row -> - iter_row (nongen_schema_rec env) row; - if not (static_row row) then nongen_schema_rec env (row_more row) - | _ -> - iter_type_expr (nongen_schema_rec env) ty - end +let add_nongen_vars_in_schema = + let rec loop env ((visited, weak_set) as acc) ty = + if TypeSet.mem ty visited + then acc + else begin + let visited = TypeSet.add ty visited in + match get_desc ty with + | Tvar _ when get_level ty <> generic_level -> + visited, TypeSet.add ty weak_set + | Tconstr _ -> + let (_, unexpanded_candidate) as unexpanded_candidate' = + fold_type_expr + (loop env) + (visited, weak_set) + ty + in + (* Using `==` is okay because `loop` will return the original set + when it does not change it. Similarly, `TypeSet.add` will return + the original set if the element is already present. *) + if unexpanded_candidate == weak_set + then (visited, weak_set) + else begin + match + loop env (visited, weak_set) + (try_expand_head try_expand_safe env ty) + with + | exception Cannot_expand -> unexpanded_candidate' + | expanded_result -> expanded_result + end + | Tfield(_, kind, t1, t2) -> + let visited, weak_set = + match field_kind_repr kind with + | Fpublic -> loop env (visited, weak_set) t1 + | _ -> visited, weak_set + in + loop env (visited, weak_set) t2 + | Tvariant row -> + let visited, weak_set = + fold_row (loop env) (visited, weak_set) row + in + if not (static_row row) + then loop env (visited, weak_set) (row_more row) + else (visited, weak_set) + | _ -> + fold_type_expr (loop env) (visited, weak_set) ty + end + in + fun env acc ty -> + let _, result = loop env (TypeSet.empty, acc) ty in + result -(* Return whether all variables of type [ty] are generic. *) -let nongen_schema env ty = - visited := TypeSet.empty; - try - nongen_schema_rec env ty; - visited := TypeSet.empty; - false - with Nongen -> - visited := TypeSet.empty; - true +(* Return all non-generic variables of [ty]. *) +let nongen_vars_in_schema env ty = + let result = add_nongen_vars_in_schema env TypeSet.empty ty in + if TypeSet.is_empty result + then None + else Some result (* Check that all type variables are generalizable *) (* Use Env.empty to prevent expansion of recursively defined object types; cf. typing-poly/poly.ml *) -let rec nongen_class_type = function - | Cty_constr (_, params, _) -> - List.exists (nongen_schema Env.empty) params - | Cty_signature sign -> - nongen_schema Env.empty sign.csig_self - || nongen_schema Env.empty sign.csig_self_row - || Meths.exists - (fun _ (_, _, ty) -> nongen_schema Env.empty ty) - sign.csig_meths - || Vars.exists - (fun _ (_, _, ty) -> nongen_schema Env.empty ty) - sign.csig_vars - | Cty_arrow (_, ty, cty) -> - nongen_schema Env.empty ty - || nongen_class_type cty +let nongen_class_type = + let add_nongen_vars_in_schema' ty weak_set = + add_nongen_vars_in_schema Env.empty weak_set ty + in + let add_nongen_vars_in_schema_fold fold m weak_set = + let f _key (_,_,ty) weak_set = + add_nongen_vars_in_schema Env.empty weak_set ty + in + fold f m weak_set + in + let rec nongen_class_type cty weak_set = + match cty with + | Cty_constr (_, params, _) -> + List.fold_left + (add_nongen_vars_in_schema Env.empty) + weak_set + params + | Cty_signature sign -> + weak_set + |> add_nongen_vars_in_schema' sign.csig_self + |> add_nongen_vars_in_schema' sign.csig_self_row + |> add_nongen_vars_in_schema_fold Meths.fold sign.csig_meths + |> add_nongen_vars_in_schema_fold Vars.fold sign.csig_vars + | Cty_arrow (_, ty, cty) -> + add_nongen_vars_in_schema' ty weak_set + |> nongen_class_type cty + in + nongen_class_type let nongen_class_declaration cty = - List.exists (nongen_schema Env.empty) cty.cty_params - || nongen_class_type cty.cty_type + List.fold_left + (add_nongen_vars_in_schema Env.empty) + TypeSet.empty + cty.cty_params + |> nongen_class_type cty.cty_type +let nongen_vars_in_class_declaration cty = + let result = nongen_class_declaration cty in + if TypeSet.is_empty result + then None + else Some result (* Normalize a type before printing, saving... *) (* Cannot use mark_type because deep_occur uses it too *) @@ -5161,7 +5331,7 @@ let rec nondep_type_rec ?(expand_private=false) env ids ty = with Not_found -> let ty' = newgenstub ~scope:(get_scope ty) in TypeHash.add nondep_hash ty ty'; - let desc = + match match get_desc ty with | Tconstr(p, tl, _abbrev) as desc -> begin try @@ -5222,9 +5392,13 @@ let rec nondep_type_rec ?(expand_private=false) env ids ty = | _ -> Tvariant row end | desc -> copy_type_desc (nondep_type_rec env ids) desc - in - Transient_expr.set_stub_desc ty' desc; - ty' + with + | desc -> + Transient_expr.set_stub_desc ty' desc; + ty' + | exception e -> + TypeHash.remove nondep_hash ty; + raise e let nondep_type env id ty = try @@ -5243,7 +5417,7 @@ let nondep_type_decl env mid is_covariant decl = let params = List.map (nondep_type_rec env mid) decl.type_params in let tk = try map_kind (nondep_type_rec env mid) decl.type_kind - with Nondep_cannot_erase _ when is_covariant -> Type_abstract + with Nondep_cannot_erase _ when is_covariant -> Type_abstract Definition and tm, priv = match decl.type_manifest with | None -> None, decl.type_private @@ -5369,6 +5543,7 @@ let nondep_cltype_declaration env ids decl = clty_variance = decl.clty_variance; clty_type = nondep_class_type env ids decl.clty_type; clty_path = decl.clty_path; + clty_hash_type = nondep_type_decl env ids false decl.clty_hash_type ; clty_loc = decl.clty_loc; clty_attributes = decl.clty_attributes; clty_uid = decl.clty_uid; diff --git a/src/ocaml/typing/ctype.mli b/src/ocaml/typing/ctype.mli index 0fdd659bc7..c6759b06c4 100644 --- a/src/ocaml/typing/ctype.mli +++ b/src/ocaml/typing/ctype.mli @@ -33,14 +33,40 @@ exception Matches_failure of Env.t * Errortrace.unification_error exception Incompatible (* Raised from [mcomp] *) -val init_def: int -> unit - (* Set the initial variable level *) -val begin_def: unit -> unit - (* Raise the variable level by one at the beginning of a definition. *) -val end_def: unit -> unit - (* Lower the variable level by one at the end of a definition *) -val begin_class_def: unit -> unit -val raise_nongen_level: unit -> unit +(* All the following wrapper functions revert to the original level, + even in case of exception. *) +val with_local_level: ?post:('a -> unit) -> (unit -> 'a) -> 'a + (* [with_local_level (fun () -> cmd) ~post] evaluates [cmd] at a + raised level. + If given, [post] is applied to the result, at the original level. + It is expected to contain only level related post-processing. *) +val with_local_level_if: bool -> (unit -> 'a) -> post:('a -> unit) -> 'a + (* Same as [with_local_level], but only raise the level conditionally. + [post] also is only called if the level is raised. *) +val with_local_level_iter: (unit -> 'a * 'b list) -> post:('b -> unit) -> 'a + (* Variant of [with_local_level], where [post] is iterated on the + returned list. *) +val with_local_level_iter_if: + bool -> (unit -> 'a * 'b list) -> post:('b -> unit) -> 'a + (* Conditional variant of [with_local_level_iter] *) +val with_level: level: int -> (unit -> 'a) -> 'a + (* [with_level ~level (fun () -> cmd)] evaluates [cmd] with + [current_level] set to [level] *) +val with_level_if: bool -> level: int -> (unit -> 'a) -> 'a + (* Conditional variant of [with_level] *) +val with_local_level_if_principal: (unit -> 'a) -> post:('a -> unit) -> 'a +val with_local_level_iter_if_principal: + (unit -> 'a * 'b list) -> post:('b -> unit) -> 'a + (* Applications of [with_local_level_if] and [with_local_level_iter_if] + to [!Clflags.principal] *) + +val with_local_level_for_class: ?post:('a -> unit) -> (unit -> 'a) -> 'a + (* Variant of [with_local_level], where the current level is raised but + the nongen level is not touched *) +val with_raised_nongen_level: (unit -> 'a) -> 'a + (* Variant of [with_local_level], + raises the nongen level to the current level *) + val reset_global_level: unit -> unit (* Reset the global level before typing an expression *) val increase_global_level: unit -> int @@ -115,6 +141,8 @@ val lower_contravariant: Env.t -> type_expr -> unit to be used before generalize for expansive expressions *) val lower_variables_only: Env.t -> int -> type_expr -> unit (* Lower all variables to the given level *) +val enforce_current_level: Env.t -> type_expr -> unit + (* Lower whole type to !current_level *) val generalize_structure: type_expr -> unit (* Generalize the structure of a type, lowering variables to !current_level *) @@ -150,18 +178,32 @@ val instance_list: type_expr list -> type_expr list (* Take an instance of a list of type schemes *) val new_local_type: ?loc:Location.t -> - ?manifest_and_scope:(type_expr * int) -> unit -> type_declaration -val existential_name: constructor_description -> type_expr -> string -val instance_constructor: - ?in_pattern:Env.t ref * int -> + ?manifest_and_scope:(type_expr * int) -> + type_origin -> type_declaration + +module Pattern_env : sig + type t = private + { mutable env : Env.t; + equations_scope : int; + (* scope for local type declarations *) + allow_recursive_equations : bool; + (* true iff checking counter examples *) + } + val make: Env.t -> equations_scope:int -> allow_recursive_equations:bool -> t + val copy: ?equations_scope:int -> t -> t + val set_env: t -> Env.t -> unit +end + +type existential_treatment = + | Keep_existentials_flexible + | Make_existentials_abstract of Pattern_env.t + +val instance_constructor: existential_treatment -> constructor_description -> type_expr list * type_expr * type_expr list (* Same, for a constructor. Also returns existentials. *) val instance_parameterized_type: ?keep_names:bool -> type_expr list -> type_expr -> type_expr list * type_expr -val instance_parameterized_type_2: - type_expr list -> type_expr list -> type_expr -> - type_expr list * type_expr list * type_expr val instance_declaration: type_declaration -> type_declaration val generic_instance_declaration: type_declaration -> type_declaration (* Same as instance_declaration, but new nodes at generic_level *) @@ -169,18 +211,23 @@ val instance_class: type_expr list -> class_type -> type_expr list * class_type val instance_poly: - ?keep_names:bool -> - bool -> type_expr list -> type_expr -> type_expr list * type_expr + ?keep_names:bool -> fixed:bool -> + type_expr list -> type_expr -> type_expr list * type_expr (* Take an instance of a type scheme containing free univars *) val polyfy: Env.t -> type_expr -> type_expr list -> type_expr * bool val instance_label: - bool -> label_description -> type_expr list * type_expr * type_expr + fixed:bool -> + label_description -> type_expr list * type_expr * type_expr (* Same, for a label *) val apply: + ?use_current_level:bool -> Env.t -> type_expr list -> type_expr -> type_expr list -> type_expr - (* [apply [p1...pN] t [a1...aN]] match the arguments [ai] to - the parameters [pi] and returns the corresponding instance of - [t]. Exception [Cannot_apply] is raised in case of failure. *) + (* [apply [p1...pN] t [a1...aN]] applies the type function + [fun p1 ... pN -> t] to the arguments [a1...aN] and returns the + resulting instance of [t]. + New nodes default to generic level except if [use_current_level] is + set to true. + Exception [Cannot_apply] is raised in case of failure. *) val try_expand_once_opt: Env.t -> type_expr -> type_expr val try_expand_safe_opt: Env.t -> type_expr -> type_expr @@ -222,8 +269,7 @@ val extract_concrete_typedecl: val unify: Env.t -> type_expr -> type_expr -> unit (* Unify the two types given. Raise [Unify] if not possible. *) val unify_gadt: - equations_level:int -> allow_recursive:bool -> - Env.t ref -> type_expr -> type_expr -> Btype.TypePairs.t + Pattern_env.t -> type_expr -> type_expr -> Btype.TypePairs.t (* Unify the two types given and update the environment with the local constraints. Raise [Unify] if not possible. Returns the pairs of types that have been equated. *) @@ -279,9 +325,9 @@ exception Filter_method_failed of filter_method_failure type class_match_failure = CM_Virtual_class | CM_Parameter_arity_mismatch of int * int - | CM_Type_parameter_mismatch of Env.t * Errortrace.equality_error + | CM_Type_parameter_mismatch of int * Env.t * Errortrace.equality_error | CM_Class_type_mismatch of Env.t * class_type * class_type - | CM_Parameter_mismatch of Env.t * Errortrace.moregen_error + | CM_Parameter_mismatch of int * Env.t * Errortrace.moregen_error | CM_Val_type_mismatch of string * Env.t * Errortrace.comparison_error | CM_Meth_type_mismatch of string * Env.t * Errortrace.comparison_error | CM_Non_mutable_value of string @@ -386,13 +432,19 @@ val nondep_cltype_declaration: val is_contractive: Env.t -> Path.t -> bool val normalize_type: type_expr -> unit -val nongen_schema: Env.t -> type_expr -> bool - (* Check whether the given type scheme contains no non-generic - type variables *) +val nongen_vars_in_schema: Env.t -> type_expr -> Btype.TypeSet.t option + (* Return any non-generic variables in the type scheme *) -val nongen_class_declaration: class_declaration -> bool - (* Check whether the given class type contains no non-generic - type variables. Uses the empty environment. *) +val nongen_vars_in_class_declaration:class_declaration -> Btype.TypeSet.t option + (* Return any non-generic variables in the class type. + Uses the empty environment. *) + +type variable_kind = Row_variable | Type_variable +type closed_class_failure = { + free_variable: type_expr * variable_kind; + meth: string; + meth_ty: type_expr; +} val free_variables: ?env:Env.t -> type_expr -> type_expr list (* If env present, then check for incomplete definitions too *) @@ -400,7 +452,7 @@ val closed_type_decl: type_declaration -> type_expr option val closed_extension_constructor: extension_constructor -> type_expr option val closed_class: type_expr list -> class_signature -> - (type_expr * bool * string * type_expr) option + closed_class_failure option (* Check whether all type variables are bound *) val unalias: type_expr -> type_expr @@ -413,7 +465,6 @@ val collapse_conj_params: Env.t -> type_expr list -> unit val get_current_level: unit -> int val wrap_trace_gadt_instances: Env.t -> ('a -> 'b) -> 'a -> 'b -val reset_reified_var_counter: unit -> unit val immediacy : Env.t -> type_expr -> Type_immediacy.t @@ -424,4 +475,3 @@ val package_subtype : (* Raises [Incompatible] *) val mcomp : Env.t -> type_expr -> type_expr -> unit - diff --git a/src/ocaml/typing/datarepr.ml b/src/ocaml/typing/datarepr.ml index 75b3a1e660..9213fe8337 100644 --- a/src/ocaml/typing/datarepr.ml +++ b/src/ocaml/typing/datarepr.ml @@ -125,7 +125,7 @@ let constructor_descrs ~current_unit ty_path decl cstrs rep = | Variant_regular -> Record_inlined idx_nonconst in constructor_args ~current_unit decl.type_private cd_args cd_res - (Path.Pdot (ty_path, cstr_name)) representation + Path.(Pextra_ty (ty_path, Pcstr_ty cstr_name)) representation in let cstr = { cstr_name; @@ -154,7 +154,7 @@ let extension_descr ~current_unit path_ext ext = in let existentials, cstr_args, cstr_inlined = constructor_args ~current_unit ext.ext_private ext.ext_args ext.ext_ret_type - path_ext (Record_extension path_ext) + Path.(Pextra_ty (path_ext, Pext_ty)) (Record_extension path_ext) in { cstr_name = Path.last path_ext; cstr_res = ty_res; @@ -228,11 +228,11 @@ let constructors_of_type ~current_unit ty_path decl = match decl.type_kind with | Type_variant (cstrs,rep) -> constructor_descrs ~current_unit ty_path decl cstrs rep - | Type_record _ | Type_abstract | Type_open -> [] + | Type_record _ | Type_abstract _ | Type_open -> [] let labels_of_type ty_path decl = match decl.type_kind with | Type_record(labels, rep) -> label_descrs (newgenconstr ty_path decl.type_params) labels rep decl.type_private - | Type_variant _ | Type_abstract | Type_open -> [] + | Type_variant _ | Type_abstract _ | Type_open -> [] diff --git a/src/ocaml/typing/dune b/src/ocaml/typing/dune index bebe62fbb2..b59003ad8a 100644 --- a/src/ocaml/typing/dune +++ b/src/ocaml/typing/dune @@ -6,5 +6,5 @@ -open Ocaml_parsing -open Merlin_utils (:standard -w -9)) - (modules_without_implementation annot outcometree) - (libraries merlin_utils ocaml_parsing ocaml_utils)) + (modules_without_implementation annot outcometree value_rec_types) + (libraries merlin_utils ocaml_compression ocaml_parsing ocaml_utils)) diff --git a/src/ocaml/typing/env.ml b/src/ocaml/typing/env.ml index 823da2ad43..4beeb037d1 100644 --- a/src/ocaml/typing/env.ml +++ b/src/ocaml/typing/env.ml @@ -40,13 +40,6 @@ let value_declarations : unit usage_tbl ref = s_table Types.Uid.Tbl.create 16 let type_declarations : unit usage_tbl ref = s_table Types.Uid.Tbl.create 16 let module_declarations : unit usage_tbl ref = s_table Types.Uid.Tbl.create 16 -let uid_to_loc : Location.t Types.Uid.Tbl.t ref = - s_table Types.Uid.Tbl.create 16 - -let register_uid uid loc = Types.Uid.Tbl.add !uid_to_loc uid loc - -let get_uid_to_loc_tbl () = !uid_to_loc - type constructor_usage = Positive | Pattern | Exported_private | Exported type constructor_usages = { @@ -105,8 +98,8 @@ let add_label_usage lu usage = lu.lu_construct <- true let is_mutating_label_usage = function -| Mutation -> true -| (Projection | Construct | Exported_private | Exported) -> false + | Mutation -> true + | (Projection | Construct | Exported_private | Exported) -> false let label_usages () = {lu_projection = false; lu_mutation = false; lu_construct = false} @@ -435,6 +428,23 @@ module IdTbl = List.map (fun (p, desc) -> (p, f desc)) (find_all wrap name next) + let rec find_all_idents name tbl () = + let current = + Ident.find_all_seq name tbl.current + |> Seq.map (fun (id, _) -> Some id) + in + let next () = + match tbl.layer with + | Nothing -> Seq.Nil + | Open { next; components; _ } -> + if NameMap.mem name components then + Seq.Cons(None, find_all_idents name next) + else + find_all_idents name next () + | Map {next; _ } -> find_all_idents name next () + in + Seq.append current next () + let rec fold_name wrap f tbl acc = let acc = Ident.fold_name @@ -504,6 +514,7 @@ let stamped_add table path value = | Pident id -> Ident.stamp id | Pdot (t, _) -> path_stamp t | Papply (t1, t2) -> Int.max (path_stamp t1) (path_stamp t2) + | Pextra_ty (t, _) -> path_stamp t in let stamp = path_stamp path in let stamp = if stamp = 0 then None else Some stamp in @@ -691,6 +702,11 @@ let error err = raise (Error err) let lookup_error loc env err = error (Lookup_error(loc, env, err)) +let same_type_declarations e1 e2 = + e1.types == e2.types && + e1.modules == e2.modules && + e1.local_constraints == e2.local_constraints + let same_constr = ref (fun _ _ _ -> assert false) let check_well_formed_module = ref (fun _ -> assert false) @@ -711,9 +727,12 @@ let check_shadowing env = function | `Label (Some (l1, l2)) when not (!same_constr env l1.lbl_res l2.lbl_res) -> Some "label" - | `Value (Some _) -> Some "value" + | `Value (Some (Val_unbound _, _)) -> None + | `Value (Some (_, _)) -> Some "value" | `Type (Some _) -> Some "type" - | `Module (Some _) | `Component (Some _) -> Some "module" + | `Module (Some (Mod_unbound _, _)) -> None + | `Module (Some _) | `Component (Some _) -> + Some "module" | `Module_type (Some _) -> Some "module type" | `Class (Some _) -> Some "class" | `Class_type (Some _) -> Some "class type" @@ -746,10 +765,6 @@ let is_in_signature env = env.flags land in_signature_flag <> 0 let has_local_constraints env = not (Path.Map.is_empty env.local_constraints) -let is_ident = function - Pident _ -> true - | Pdot _ | Papply _ -> false - let is_ext cda = match cda.cda_description with | {cstr_tag = Cstr_extension _} -> true @@ -757,7 +772,11 @@ let is_ext cda = let is_local_ext cda = match cda.cda_description with - | {cstr_tag = Cstr_extension(p, _)} -> is_ident p + | {cstr_tag = Cstr_extension(p, _)} -> begin + match p with + | Pident _ -> true + | Pdot _ | Papply _ | Pextra_ty _ -> false + end | _ -> false let diff env1 env2 = @@ -836,7 +855,7 @@ end = struct Ident.persistent id && is (Ident.name id) let is_path = function | Pident id -> is_ident id - | Pdot _ | Papply _ -> false + | Pdot _ | Papply _ | Pextra_ty _ -> false end let set_unit_name = Current_unit_name.set @@ -967,9 +986,9 @@ let imports () = Persistent_env.imports !persistent_env let import_crcs ~source crcs = Persistent_env.import_crcs !persistent_env ~source crcs -let read_pers_mod modname filename = +let read_pers_mod cmi = Persistent_env.read !persistent_env - read_sign_of_cmi short_paths_components modname filename + read_sign_of_cmi short_paths_components cmi let find_pers_mod name = Persistent_env.find !persistent_env @@ -995,7 +1014,6 @@ let reset_declaration_caches () = Types.Uid.Tbl.clear !module_declarations; Types.Uid.Tbl.clear !used_constructors; Types.Uid.Tbl.clear !used_labels; - Types.Uid.Tbl.clear !uid_to_loc; () let reset_cache () = @@ -1062,7 +1080,7 @@ let find_ident_module id env = match find_same_module id env.modules with | Mod_local data -> data | Mod_unbound _ -> raise Not_found - | Mod_persistent -> find_pers_mod (Ident.name id) + | Mod_persistent -> find_pers_mod ~allow_hidden:true (Ident.name id) let rec find_module_components path env = match path with @@ -1074,6 +1092,7 @@ let rec find_module_components path env = let f_comp = find_functor_components f_path env in let loc = Location.(in_file !input_name) in !components_of_functor_appl' ~loc ~f_path ~f_comp ~arg env + | Pextra_ty _ -> raise Not_found and find_structure_components path env = match get_components (find_module_components path env) with @@ -1098,6 +1117,7 @@ let find_module ~alias path env = let fc = find_functor_components p1 env in if alias then md (fc.fcomp_res) else md (modtype_of_functor_appl fc p1 p2) + | Pextra_ty _ -> raise Not_found let find_module_lazy ~alias path env = match path with @@ -1115,6 +1135,7 @@ let find_module_lazy ~alias path env = else md (modtype_of_functor_appl fc p1 p2) in Subst.Lazy.of_module_decl md + | Pextra_ty _ -> raise Not_found let find_strengthened_module ~aliasable path env = let md = find_module_lazy ~alias:true path env in @@ -1131,15 +1152,70 @@ let find_value_full path env = | Pdot(p, s) -> let sc = find_structure_components p env in NameMap.find s sc.comp_values - | Papply _ -> raise Not_found + | Papply _ | Pextra_ty _ -> raise Not_found -let find_type_full path env = +let find_extension_full path env = match path with - | Pident id -> IdTbl.find_same id env.types - | Pdot(p, s) -> - let sc = find_structure_components p env in - NameMap.find s sc.comp_types - | Papply _ -> raise Not_found + | Pident id -> TycompTbl.find_same id env.constrs + | Pdot(p, s) -> begin + let comps = find_structure_components p env in + let cstrs = NameMap.find s comps.comp_constrs in + let exts = List.filter is_ext cstrs in + match exts with + | [cda] -> cda + | _ -> raise Not_found + end + | Papply _ | Pextra_ty _ -> raise Not_found + +let type_of_cstr path = function + | {cstr_inlined = Some decl; _} -> + let labels = + List.map snd (Datarepr.labels_of_type path decl) + in + begin match decl.type_kind with + | Type_record (_, repr) -> + { + tda_declaration = decl; + tda_descriptions = Type_record (labels, repr); + tda_shape = Shape.leaf decl.type_uid; + } + | _ -> assert false + end + | _ -> assert false + +let rec find_type_data path env = + match Path.Map.find path env.local_constraints with + | decl -> + { + tda_declaration = decl; + tda_descriptions = Type_abstract (Btype.type_origin decl); + tda_shape = Shape.leaf decl.type_uid; + } + | exception Not_found -> begin + match path with + | Pident id -> IdTbl.find_same id env.types + | Pdot(p, s) -> + let sc = find_structure_components p env in + NameMap.find s sc.comp_types + | Papply _ -> raise Not_found + | Pextra_ty (p, extra) -> begin + match extra with + | Pcstr_ty s -> + let cstr = find_cstr p s env in + type_of_cstr path cstr + | Pext_ty -> + let cda = find_extension_full p env in + type_of_cstr path cda.cda_description + end + end +and find_cstr path name env = + let tda = find_type_data path env in + match tda.tda_descriptions with + | Type_variant (cstrs, _) -> + List.find (fun cstr -> cstr.cstr_name = name) cstrs + | Type_record _ | Type_abstract _ | Type_open -> raise Not_found + + let find_modtype_lazy path env = match path with @@ -1147,7 +1223,7 @@ let find_modtype_lazy path env = | Pdot(p, s) -> let sc = find_structure_components p env in (NameMap.find s sc.comp_modtypes).mtda_declaration - | Papply _ -> raise Not_found + | Papply _ | Pextra_ty _ -> raise Not_found let find_modtype path env = Subst.Lazy.force_modtype_decl (find_modtype_lazy path env) @@ -1158,7 +1234,7 @@ let find_class_full path env = | Pdot(p, s) -> let sc = find_structure_components p env in NameMap.find s sc.comp_classes - | Papply _ -> raise Not_found + | Papply _ | Pextra_ty _ -> raise Not_found let find_cltype path env = match path with @@ -1166,7 +1242,7 @@ let find_cltype path env = | Pdot(p, s) -> let sc = find_structure_components p env in (NameMap.find s sc.comp_cltypes).cltda_declaration - | Papply _ -> raise Not_found + | Papply _ | Pextra_ty _ -> raise Not_found let find_value path env = (find_value_full path env).vda_description @@ -1180,71 +1256,6 @@ let find_ident_constructor id env = let find_ident_label id env = TycompTbl.find_same id env.labels -let type_of_cstr path = function - | {cstr_inlined = Some decl; _} -> - let labels = - List.map snd (Datarepr.labels_of_type path decl) - in - begin match decl.type_kind with - | Type_record (_, repr) -> - { - tda_declaration = decl; - tda_descriptions = Type_record (labels, repr); - tda_shape = Shape.leaf decl.type_uid; - } - | _ -> assert false - end - | _ -> assert false - -let find_type_data path env = - match Path.constructor_typath path with - | Regular p -> begin - match Path.Map.find p env.local_constraints with - | decl -> - { - tda_declaration = decl; - tda_descriptions = Type_abstract; - tda_shape = Shape.leaf decl.type_uid; - } - | exception Not_found -> find_type_full p env - end - | Cstr (ty_path, s) -> - (* This case corresponds to an inlined record *) - let tda = - try find_type_full ty_path env - with Not_found -> assert false - in - let cstr = - begin match tda.tda_descriptions with - | Type_variant (cstrs, _) -> begin - try - List.find (fun cstr -> cstr.cstr_name = s) cstrs - with Not_found -> assert false - end - | Type_record _ | Type_abstract | Type_open -> assert false - end - in - type_of_cstr path cstr - | LocalExt id -> - let cstr = - try (TycompTbl.find_same id env.constrs).cda_description - with Not_found -> assert false - in - type_of_cstr path cstr - | Ext (mod_path, s) -> - let comps = - try find_structure_components mod_path env - with Not_found -> assert false - in - let cstrs = - try NameMap.find s comps.comp_constrs - with Not_found -> assert false - in - let exts = List.filter is_ext cstrs in - match exts with - | [cda] -> type_of_cstr path cda.cda_description - | _ -> assert false - let find_type p env = (find_type_data p env).tda_declaration let find_type_descrs p env = @@ -1256,7 +1267,7 @@ let rec find_module_address path env = | Pdot(p, s) -> let c = find_structure_components p env in get_address (NameMap.find s c.comp_modules).mda_address - | Papply _ -> raise Not_found + | Papply _ | Pextra_ty _ -> raise Not_found and force_address = function | Projection { parent; pos } -> Adot(get_address parent, pos) @@ -1289,29 +1300,30 @@ let find_constructor_address path env = | Pdot(p, s) -> let c = find_structure_components p env in get_constrs_address (NameMap.find s c.comp_constrs) - | Papply _ -> - raise Not_found + | Papply _ | Pextra_ty _ -> raise Not_found let find_hash_type path env = match path with | Pident id -> - let name = "#" ^ Ident.name id in - let _, tda = - IdTbl.find_name wrap_identity ~mark:false name env.types + let name = Ident.name id in + let _, cltda = + IdTbl.find_name wrap_identity ~mark:false name env.cltypes in - tda.tda_declaration - | Pdot(p, s) -> + cltda.cltda_declaration.clty_hash_type + | Pdot(p, name) -> let c = find_structure_components p env in - let name = "#" ^ s in - let tda = NameMap.find name c.comp_types in - tda.tda_declaration - | Papply _ -> - raise Not_found + let cltda = NameMap.find name c.comp_cltypes in + cltda.cltda_declaration.clty_hash_type + | Papply _ | Pextra_ty _ -> raise Not_found let find_shape env (ns : Shape.Sig_component_kind.t) id = match ns with | Type -> (IdTbl.find_same id env.types).tda_shape + | Constructor -> + Shape.leaf ((TycompTbl.find_same id env.constrs).cda_description.cstr_uid) + | Label -> + Shape.leaf ((TycompTbl.find_same id env.labels).lbl_uid) | Extension_constructor -> (TycompTbl.find_same id env.constrs).cda_shape | Value -> @@ -1369,6 +1381,7 @@ let rec normalize_module_path lax env = function else expand_module_path lax env (Papply(p1', p2')) | Pident _ as path -> expand_module_path lax env path + | Pextra_ty _ -> assert false and expand_module_path lax env path = try match find_module_lazy ~alias:true path env with @@ -1392,36 +1405,22 @@ let normalize_module_path oloc env path = error (Missing_module(loc, path, normalize_module_path true env path)) -let normalize_path_prefix oloc env path = +let rec normalize_path_prefix oloc env path = match path with - Pdot(p, s) -> + | Pdot(p, s) -> let p2 = normalize_module_path oloc env p in if p == p2 then path else Pdot(p2, s) | Pident _ -> path - | Papply _ -> + | Pextra_ty (p, extra) -> + let p2 = normalize_path_prefix oloc env p in + if p == p2 then path else Pextra_ty (p2, extra) + | Papply _ -> assert false -let normalize_type_path oloc env path = - (* Inlined version of Path.is_constructor_typath: - constructor type paths (i.e. path pointing to an inline - record argument of a constructpr) are built as a regular - type path followed by a capitalized constructor name. *) - match path with - | Pident _ -> - path - | Pdot(p, s) -> - let p2 = - if Path.is_uident s && not (Path.is_uident (Path.last p)) then - (* Cstr M.t.C *) - normalize_path_prefix oloc env p - else - (* Regular M.t, Ext M.C *) - normalize_module_path oloc env p - in - if p == p2 then path else Pdot (p2, s) - | Papply _ -> - assert false +let normalize_type_path = normalize_path_prefix + +let normalize_value_path = normalize_path_prefix let rec normalize_modtype_path env path = let path = normalize_path_prefix None env path in @@ -1445,7 +1444,7 @@ let find_type_expansion path env = let decl = find_type path env in match decl.type_manifest with | Some body when decl.type_private = Public - || decl.type_kind <> Type_abstract + || not (Btype.type_kind_is_abstract decl) || Btype.has_constr_row body -> (decl.type_params, body, decl.type_expansion_scope) (* The manifest type of Private abstract data types without @@ -1481,7 +1480,7 @@ let rec is_functor_arg path env = begin try Ident.find_same id env.functor_args; true with Not_found -> false end - | Pdot (p, _s) -> is_functor_arg p env + | Pdot (p, _) | Pextra_ty (p, _) -> is_functor_arg p env | Papply _ -> true (* Copying types associated with values *) @@ -1616,7 +1615,7 @@ let rec find_shadowed_comps path env = (fun comps -> comps.comp_modules) s) l in List.flatten l' - | Papply _ -> [] + | Papply _ | Pextra_ty _ -> [] let find_shadowed wrap proj1 proj2 path env = match path with @@ -1626,7 +1625,7 @@ let find_shadowed wrap proj1 proj2 path env = let l = find_shadowed_comps p env in let l' = List.map (find_all_comps wrap proj2 s) l in List.flatten l' - | Papply _ -> [] + | Papply _ | Pextra_ty _ -> [] let find_shadowed_types path env = List.map fst @@ -1865,7 +1864,7 @@ let rec components_of_module_maker add_to_tbl descr.lbl_name descr c.comp_labels) lbls; Type_record (lbls, repr) - | Type_abstract -> Type_abstract + | Type_abstract r -> Type_abstract r | Type_open -> Type_open in let shape = Shape.proj cm_shape (Shape.Item.type_ id) in @@ -2008,6 +2007,7 @@ and check_value_name name loc = and store_value ?check id addr decl shape env = check_value_name (Ident.name id) decl.val_loc; + Builtin_attributes.mark_alerts_used decl.val_attributes; Option.iter (fun f -> check_usage decl.val_loc id decl.val_uid f !value_declarations) check; @@ -2021,6 +2021,7 @@ and store_value ?check id addr decl shape env = summary = Env_value(env.summary, id, decl) } and store_constructor ~check type_decl type_id cstr_id cstr env = + Builtin_attributes.warning_scope cstr.cstr_attributes (fun () -> if check && not type_decl.type_loc.Location.loc_ghost && Warnings.is_active (Warnings.Unused_constructor ("", Unused)) then begin @@ -2044,7 +2045,9 @@ and store_constructor ~check type_decl type_id cstr_id cstr env = (Warnings.Unused_constructor(name, complaint))) (constructor_usage_complaint ~rebind:false priv used)); end; - end; + end); + Builtin_attributes.mark_alerts_used cstr.cstr_attributes; + Builtin_attributes.mark_warn_on_literal_pattern_used cstr.cstr_attributes; let cda_shape = Shape.leaf cstr.cstr_uid in { env with constrs = @@ -2053,6 +2056,7 @@ and store_constructor ~check type_decl type_id cstr_id cstr env = } and store_label ~check type_decl type_id lbl_id lbl env = + Builtin_attributes.warning_scope lbl.lbl_attributes (fun () -> if check && not type_decl.type_loc.Location.loc_ghost && Warnings.is_active (Warnings.Unused_field ("", Unused)) then begin @@ -2075,7 +2079,10 @@ and store_label ~check type_decl type_id lbl_id lbl env = Location.prerr_warning loc (Warnings.Unused_field(name, complaint))) (label_usage_complaint priv mut used)) - end; + end); + Builtin_attributes.mark_alerts_used lbl.lbl_attributes; + if lbl.lbl_mut = Mutable then + Builtin_attributes.mark_deprecated_mutable_used lbl.lbl_attributes; { env with labels = TycompTbl.add lbl_id lbl env.labels; } @@ -2105,7 +2112,7 @@ and store_type ~check ~long_path ~predef id info shape env = (fun env (lbl_id, lbl) -> store_label ~check info id lbl_id lbl env) env labels - | Type_abstract -> Type_abstract, env + | Type_abstract r -> Type_abstract r, env | Type_open -> Type_open, env in let tda = @@ -2113,6 +2120,7 @@ and store_type ~check ~long_path ~predef id info shape env = tda_descriptions = descrs; tda_shape = shape } in + Builtin_attributes.mark_alerts_used info.type_attributes; { env with types = IdTbl.add id tda env.types; summary = Env_type(env.summary, id, info); @@ -2128,7 +2136,7 @@ and store_type_infos ~tda_shape id info env = let tda = { tda_declaration = info; - tda_descriptions = Type_abstract; + tda_descriptions = Type_abstract (Btype.type_origin info); tda_shape } in @@ -2148,6 +2156,9 @@ and store_extension ~check ~rebind id addr ext shape env = cda_address = Some addr; cda_shape = shape } in + Builtin_attributes.mark_alerts_used ext.ext_attributes; + Builtin_attributes.mark_warn_on_literal_pattern_used ext.ext_attributes; + Builtin_attributes.warning_scope ext.ext_attributes (fun () -> if check && not loc.Location.loc_ghost && Warnings.is_active (Warnings.Unused_extension ("", false, Unused)) then begin @@ -2169,7 +2180,7 @@ and store_extension ~check ~rebind id addr ext shape env = (name, is_exception, complaint))) (constructor_usage_complaint ~rebind priv used)) end; - end; + end); { env with constrs = TycompTbl.add id cda env.constrs; summary = Env_extension(env.summary, id, ext) } @@ -2180,6 +2191,7 @@ and store_module ?(update_summary=true) ~check let loc = md.mdl_loc in Option.iter (fun f -> check_usage loc id md.mdl_uid f !module_declarations) check; + Builtin_attributes.mark_alerts_used md.mdl_attributes; let alerts = Builtin_attributes.alerts_of_attrs md.mdl_attributes in let comps = components_of_module ~alerts ~uid:md.mdl_uid @@ -2201,6 +2213,7 @@ and store_module ?(update_summary=true) ~check short_paths_module id md comps env.short_paths_additions; } and store_modtype ?(update_summary=true) id info shape env = + Builtin_attributes.mark_alerts_used info.Subst.Lazy.mtdl_attributes; let mtda = { mtda_declaration = info; mtda_shape = shape } in let summary = if not update_summary then env.summary @@ -2212,6 +2225,7 @@ and store_modtype ?(update_summary=true) id info shape env = short_paths_module_type id info env.short_paths_additions; } and store_class id addr desc shape env = + Builtin_attributes.mark_alerts_used desc.cty_attributes; let clda = { clda_declaration = desc; clda_address = addr; @@ -2222,6 +2236,7 @@ and store_class id addr desc shape env = summary = Env_class(env.summary, id, desc) } and store_cltype id desc shape env = + Builtin_attributes.mark_alerts_used desc.clty_attributes; let cltda = { cltda_declaration = desc; cltda_shape = shape } in { env with cltypes = IdTbl.add id cltda env.cltypes; @@ -2342,7 +2357,7 @@ let add_module_lazy ~update_summary id presence mty env = in add_module_declaration_lazy ~update_summary id presence md env -let add_local_type path info env = +let add_local_constraint path info env = { env with local_constraints = Path.Map.add path info env.local_constraints } @@ -2453,8 +2468,6 @@ let enter_signature_and_shape ~scope ~parent_shape mod_shape sg env = enter_signature_and_shape ~scope ~parent_shape (Some mod_shape) sg env let add_value = add_value ?shape:None -let add_type = add_type ?shape:None -let add_extension = add_extension ?shape:None let add_class = add_class ?shape:None let add_cltype = add_cltype ?shape:None let add_modtype = add_modtype ?shape:None @@ -2648,29 +2661,19 @@ let open_signature else open_signature None root env (* Read a signature from a file *) -let read_signature modname filename = - let mda = read_pers_mod modname filename in +let read_signature u = + let mda = read_pers_mod u in let md = Subst.Lazy.force_module_decl mda.mda_declaration in match md.md_type with | Mty_signature sg -> sg | Mty_ident _ | Mty_functor _ | Mty_alias _ | Mty_for_hole -> assert false -let is_identchar_latin1 = function - | 'A'..'Z' | 'a'..'z' | '_' | '\192'..'\214' | '\216'..'\246' - | '\248'..'\255' | '\'' | '0'..'9' -> true - | _ -> false - let unit_name_of_filename fn = match Filename.extension fn with - | ".cmi" -> begin - let unit = - String.capitalize_ascii (Filename.remove_extension fn) - in - if Std.String.for_all is_identchar_latin1 unit then - Some unit - else - None - end + | ".cmi" -> + let modname = Unit_info.modname_from_source fn in + if Unit_info.is_unit_name modname then Some modname + else None | _ -> None let persistent_structures_of_dir dir = @@ -2680,40 +2683,41 @@ let persistent_structures_of_dir dir = |> String.Set.of_seq (* Save a signature to a file *) -let save_signature_with_transform cmi_transform ~alerts sg modname filename = +let save_signature_with_transform cmi_transform ~alerts sg cmi_info = Btype.cleanup_abbrev (); Subst.reset_for_saving (); let sg = Subst.signature Make_local (Subst.for_saving Subst.identity) sg in let cmi = - Persistent_env.make_cmi !persistent_env modname sg alerts + Persistent_env.make_cmi !persistent_env + (Unit_info.Artifact.modname cmi_info) sg alerts |> cmi_transform in - let pm = save_sign_of_cmi - { Persistent_env.Persistent_signature.cmi; filename } in - Persistent_env.save_cmi !persistent_env - { Persistent_env.Persistent_signature.filename; cmi } pm; + let filename = Unit_info.Artifact.filename cmi_info in + let pers_sig = + Persistent_env.Persistent_signature.{ cmi; filename; visibility = Visible } + in + let pm = save_sign_of_cmi pers_sig in + Persistent_env.save_cmi !persistent_env pers_sig pm; cmi -let save_signature ~alerts sg modname filename = - save_signature_with_transform (fun cmi -> cmi) - ~alerts sg modname filename +let save_signature ~alerts sg cmi = + save_signature_with_transform (fun cmi -> cmi) ~alerts sg cmi -let save_signature_with_imports ~alerts sg modname filename imports = +let save_signature_with_imports ~alerts sg cmi imports = let with_imports cmi = { cmi with cmi_crcs = imports } in - save_signature_with_transform with_imports - ~alerts sg modname filename + save_signature_with_transform with_imports ~alerts sg cmi (* Make the initial environment *) -let (initial_safe_string, initial_unsafe_string) = +let initial = Predef.build_initial_env (add_type ~check:false ~predef:true ~long_path:false) (add_extension ~check:false ~rebind:false) empty -let add_type_long_path ~check id info env = - add_type ~check ~predef:false ~long_path:true id info env +let add_type_long_path ~check ?shape id info env = + add_type ~check ?shape ~predef:false ~long_path:true id info env -let add_type ~check id info env = - add_type ~check ~predef:false ~long_path:false id info env +let add_type ~check ?shape id info env = + add_type ~check ?shape ~predef:false ~long_path:false id info env (* Tracking usage *) @@ -2918,10 +2922,10 @@ let lookup_ident_module (type a) (load : a load) ~errors ~use ~loc s env = | Mod_persistent -> begin match load with | Don't_load -> - check_pers_mod ~loc s; + check_pers_mod ~allow_hidden:false ~loc s; path, (() : a) | Load -> begin - match find_pers_mod s with + match find_pers_mod ~allow_hidden:false s with | mda -> use_module ~use ~loc path mda; path, (mda : a) @@ -3181,7 +3185,7 @@ let lookup_all_dot_constructors ~errors ~use ~loc usage l s env = | Longident.Lident "*predef*" -> (* Hack to support compilation of default arguments *) lookup_all_ident_constructors - ~errors ~use ~loc usage s initial_safe_string + ~errors ~use ~loc usage s initial | _ -> let (_, comps) = lookup_structure_components ~errors ~use ~loc l env in match NameMap.find s comps.comp_constrs with @@ -3260,7 +3264,7 @@ let lookup_label ~errors ~use ~loc usage lid env = let lookup_all_labels_from_type ~use ~loc usage ty_path env = match find_type_descrs ty_path env with | exception Not_found -> [] - | Type_variant _ | Type_abstract | Type_open -> [] + | Type_variant _ | Type_abstract _ | Type_open -> [] | Type_record (lbls, _) -> List.map (fun lbl -> @@ -3282,7 +3286,7 @@ let lookup_constructor ~errors ~use ~loc usage lid env = let lookup_all_constructors_from_type ~use ~loc usage ty_path env = match find_type_descrs ty_path env with | exception Not_found -> [] - | Type_record _ | Type_abstract | Type_open -> [] + | Type_record _ | Type_abstract _ | Type_open -> [] | Type_variant (cstrs, _) -> List.map (fun cstr -> @@ -3328,6 +3332,23 @@ let find_label_by_name lid env = let loc = Location.(in_file !input_name) in lookup_label ~errors:false ~use:false ~loc Projection lid env +(* Stable name lookup for printing *) + +let find_index_tbl ident tbl = + let lbs = IdTbl.find_all_idents (Ident.name ident) tbl in + let find_ident (n,p) = match p with + | Some id -> if Ident.same ident id then Some n else None + | _ -> None + in + Seq.find_map find_ident @@ Seq.mapi (fun i x -> i,x) lbs + +let find_value_index id env = find_index_tbl id env.values +let find_type_index id env = find_index_tbl id env.types +let find_module_index id env = find_index_tbl id env.modules +let find_modtype_index id env = find_index_tbl id env.modtypes +let find_class_index id env = find_index_tbl id env.classes +let find_cltype_index id env = find_index_tbl id env.cltypes + (* Ordinary lookup functions *) let lookup_module_path ?(use=true) ~loc ~load lid env = @@ -3409,7 +3430,7 @@ let bound_module name env = | exception Not_found -> if Current_unit_name.is name then false else begin - match find_pers_mod name with + match find_pers_mod ~allow_hidden:false name with | _ -> true | exception Not_found -> false end @@ -3682,9 +3703,12 @@ let extract_instance_variables env = | Val_ivar _ -> name :: acc | _ -> acc) None env [] +module Style = Misc.Style + let report_lookup_error _loc env ppf = function | Unbound_value(lid, hint) -> begin - fprintf ppf "Unbound value %a" !print_longident lid; + fprintf ppf "Unbound value %a" + (Style.as_inline_code !print_longident) lid; spellcheck ppf extract_values env lid; match hint with | No_hint -> () @@ -3693,94 +3717,101 @@ let report_lookup_error _loc env ppf = function Location.get_pos_info def_loc.Location.loc_start in fprintf ppf - "@.@[%s@ %s %i@]" - "Hint: If this is a recursive definition," - "you should add the 'rec' keyword on line" + "@.@[@{Hint@}: If this is a recursive definition,@ \ + you should add the %a keyword on line %i@]" + Style.inline_code "rec" line end | Unbound_type lid -> - fprintf ppf "Unbound type constructor %a" !print_longident lid; + fprintf ppf "Unbound type constructor %a" + (Style.as_inline_code !print_longident) lid; spellcheck ppf extract_types env lid; | Unbound_module lid -> begin - fprintf ppf "Unbound module %a" !print_longident lid; + fprintf ppf "Unbound module %a" + (Style.as_inline_code !print_longident) lid; match find_modtype_by_name lid env with | exception Not_found -> spellcheck ppf extract_modules env lid; | _ -> fprintf ppf - "@.@[%s %a, %s@]" - "Hint: There is a module type named" - !print_longident lid + "@.@[@{Hint@}: There is a module type named %a, %s@]" + (Style.as_inline_code !print_longident) lid "but module types are not modules" end | Unbound_constructor lid -> - fprintf ppf "Unbound constructor %a" !print_longident lid; + fprintf ppf "Unbound constructor %a" + (Style.as_inline_code !print_longident) lid; spellcheck ppf extract_constructors env lid; | Unbound_label lid -> - fprintf ppf "Unbound record field %a" !print_longident lid; + fprintf ppf "Unbound record field %a" + (Style.as_inline_code !print_longident) lid; spellcheck ppf extract_labels env lid; | Unbound_class lid -> begin - fprintf ppf "Unbound class %a" !print_longident lid; + fprintf ppf "Unbound class %a" + (Style.as_inline_code !print_longident) lid; match find_cltype_by_name lid env with | exception Not_found -> spellcheck ppf extract_classes env lid; | _ -> fprintf ppf - "@.@[%s %a, %s@]" - "Hint: There is a class type named" - !print_longident lid + "@.@[@{Hint@}: There is a class type named %a, %s@]" + (Style.as_inline_code !print_longident) lid "but classes are not class types" end | Unbound_modtype lid -> begin - fprintf ppf "Unbound module type %a" !print_longident lid; + fprintf ppf "Unbound module type %a" + (Style.as_inline_code !print_longident) lid; match find_module_by_name lid env with | exception Not_found -> spellcheck ppf extract_modtypes env lid; | _ -> fprintf ppf - "@.@[%s %a, %s@]" - "Hint: There is a module named" - !print_longident lid + "@.@[@{Hint@}: There is a module named %a, %s@]" + (Style.as_inline_code !print_longident) lid "but modules are not module types" end | Unbound_cltype lid -> - fprintf ppf "Unbound class type %a" !print_longident lid; + fprintf ppf "Unbound class type %a" + (Style.as_inline_code !print_longident) lid; spellcheck ppf extract_cltypes env lid; | Unbound_instance_variable s -> - fprintf ppf "Unbound instance variable %s" s; + fprintf ppf "Unbound instance variable %a" Style.inline_code s; spellcheck_name ppf extract_instance_variables env s; | Not_an_instance_variable s -> - fprintf ppf "The value %s is not an instance variable" s; + fprintf ppf "The value %a is not an instance variable" + Style.inline_code s; spellcheck_name ppf extract_instance_variables env s; | Masked_instance_variable lid -> fprintf ppf "The instance variable %a@ \ cannot be accessed from the definition of another instance variable" - !print_longident lid + (Style.as_inline_code !print_longident) lid | Masked_self_variable lid -> fprintf ppf "The self variable %a@ \ cannot be accessed from the definition of an instance variable" - !print_longident lid + (Style.as_inline_code !print_longident) lid | Masked_ancestor_variable lid -> fprintf ppf "The ancestor variable %a@ \ cannot be accessed from the definition of an instance variable" - !print_longident lid + (Style.as_inline_code !print_longident) lid | Illegal_reference_to_recursive_module -> fprintf ppf "Illegal recursive module reference" | Structure_used_as_functor lid -> fprintf ppf "@[The module %a is a structure, it cannot be applied@]" - !print_longident lid + (Style.as_inline_code !print_longident) lid | Abstract_used_as_functor lid -> fprintf ppf "@[The module %a is abstract, it cannot be applied@]" - !print_longident lid + (Style.as_inline_code !print_longident) lid | Functor_used_as_structure lid -> fprintf ppf "@[The module %a is a functor, \ it cannot have any components@]" !print_longident lid | Abstract_used_as_structure lid -> fprintf ppf "@[The module %a is abstract, \ - it cannot have any components@]" !print_longident lid + it cannot have any components@]" + (Style.as_inline_code !print_longident) lid | Generative_used_as_applicative lid -> fprintf ppf "@[The functor %a is generative,@ it@ cannot@ be@ \ - applied@ in@ type@ expressions@]" !print_longident lid + applied@ in@ type@ expressions@]" + (Style.as_inline_code !print_longident) lid | Cannot_scrape_alias(lid, p) -> let cause = if Current_unit_name.is_path p then "is the current compilation unit" @@ -3788,22 +3819,26 @@ let report_lookup_error _loc env ppf = function in fprintf ppf "The module %a is an alias for module %a, which %s" - !print_longident lid !print_path p cause + (Style.as_inline_code !print_longident) lid + (Style.as_inline_code !print_path) p cause let report_error ppf = function | Missing_module(_, path1, path2) -> fprintf ppf "@[@["; if Path.same path1 path2 then - fprintf ppf "Internal path@ %s@ is dangling." (Path.name path1) + fprintf ppf "Internal path@ %a@ is dangling." + Style.inline_code (Path.name path1) else - fprintf ppf "Internal path@ %s@ expands to@ %s@ which is dangling." - (Path.name path1) (Path.name path2); - fprintf ppf "@]@ @[%s@ %s@ %s.@]@]" - "The compiled interface for module" (Ident.name (Path.head path2)) + fprintf ppf "Internal path@ %a@ expands to@ %a@ which is dangling." + Style.inline_code (Path.name path1) + Style.inline_code (Path.name path2); + fprintf ppf "@]@ @[%s@ %a@ %s.@]@]" + "The compiled interface for module" + Style.inline_code (Ident.name (Path.head path2)) "was not found" | Illegal_value_name(_loc, name) -> - fprintf ppf "'%s' is not a valid value identifier." - name + fprintf ppf "%a is not a valid value identifier." + Style.inline_code name | Lookup_error(loc, t, err) -> report_lookup_error loc t ppf err let () = @@ -3830,7 +3865,7 @@ let () = let check_state_consistency () = let missing modname = - match Load_path.find_uncap (modname ^ ".cmi") with + match Load_path.find_normalized (modname ^ ".cmi") with | _ -> false | exception Not_found -> true and found _modname filename ps_name _md = @@ -3865,7 +3900,7 @@ let short_paths_type_desc decl = if ty.level <> Btype.generic_level then Fresh else begin match decl.type_private, decl.type_kind with - | Private, Type_abstract -> Fresh + | Private, Type_abstract _ -> Fresh | _, _ -> begin let params = List.map get_desc decl.type_params in match ty with diff --git a/src/ocaml/typing/env.mli b/src/ocaml/typing/env.mli index 03ae201cd7..0a052fed3b 100644 --- a/src/ocaml/typing/env.mli +++ b/src/ocaml/typing/env.mli @@ -18,10 +18,6 @@ open Types open Misc -val register_uid : Uid.t -> Location.t -> unit - -val get_uid_to_loc_tbl : unit -> Location.t Types.Uid.Tbl.t - type value_unbound_reason = | Val_unbound_instance_variable | Val_unbound_self @@ -57,10 +53,12 @@ type address = type t val empty: t -val initial_safe_string: t -val initial_unsafe_string: t +val initial: t val diff: t -> t -> Ident.t list +(* approximation to the preimage equivalence class of [find_type] *) +val same_type_declarations: t -> t -> bool + type type_descr_kind = (label_description, constructor_description) type_kind @@ -128,9 +126,8 @@ val normalize_module_path: Location.t option -> t -> Path.t -> Path.t val normalize_type_path: Location.t option -> t -> Path.t -> Path.t (* Normalize the prefix part of the type path *) -val normalize_path_prefix: Location.t option -> t -> Path.t -> Path.t -(* Normalize the prefix part of other kinds of paths - (value/modtype/etc) *) +val normalize_value_path: Location.t option -> t -> Path.t -> Path.t +(* Normalize the prefix part of the value path *) val normalize_modtype_path: t -> Path.t -> Path.t (* Normalize a module type path *) @@ -269,6 +266,21 @@ val find_constructor_by_name: val find_label_by_name: Longident.t -> t -> label_description +(** The [find_*_index] functions computes a "namespaced" De Bruijn index + of an identifier in a given environment. In other words, it returns how many + times an identifier has been shadowed by a more recent identifiers with the + same name in a given environment. + Those functions return [None] when the identifier is not bound in the + environment. This behavior is there to facilitate the detection of + inconsistent printing environment, but should disappear in the long term. +*) +val find_value_index: Ident.t -> t -> int option +val find_type_index: Ident.t -> t -> int option +val find_module_index: Ident.t -> t -> int option +val find_modtype_index: Ident.t -> t -> int option +val find_class_index: Ident.t -> t -> int option +val find_cltype_index: Ident.t -> t -> int option + (* Check if a name is bound *) val bound_value: string -> t -> bool @@ -284,10 +296,13 @@ val make_copy_of_types: t -> (t -> t) val add_value: ?check:(string -> Warnings.t) -> Ident.t -> value_description -> t -> t -val add_type: check:bool -> Ident.t -> type_declaration -> t -> t -val add_type_long_path: check:bool -> Ident.t -> type_declaration -> t -> t +val add_type: + check:bool -> ?shape:Shape.t -> Ident.t -> type_declaration -> t -> t +val add_type_long_path: + check:bool -> ?shape:Shape.t -> Ident.t -> type_declaration -> t -> t val add_extension: - check:bool -> rebind:bool -> Ident.t -> extension_constructor -> t -> t + check:bool -> ?shape:Shape.t -> rebind:bool -> Ident.t -> + extension_constructor -> t -> t val add_module: ?arg:bool -> ?shape:Shape.t -> Ident.t -> module_presence -> module_type -> t -> t val add_module_lazy: update_summary:bool -> @@ -301,7 +316,7 @@ val add_modtype_lazy: update_summary:bool -> Ident.t -> Subst.Lazy.modtype_declaration -> t -> t val add_class: Ident.t -> class_declaration -> t -> t val add_cltype: Ident.t -> class_type_declaration -> t -> t -val add_local_type: Path.t -> type_declaration -> t -> t +val add_local_constraint: Path.t -> type_declaration -> t -> t (* Insertion of persistent signatures *) @@ -313,7 +328,7 @@ val add_local_type: Path.t -> type_declaration -> t -> t contents of the module is accessed. *) val add_persistent_structure : Ident.t -> t -> t -(* Returns the set of persistent structures found in the given + (* Returns the set of persistent structures found in the given directory. *) val persistent_structures_of_dir : Load_path.Dir.t -> Misc.String.Set.t @@ -386,14 +401,14 @@ val set_unit_name: string -> unit val get_unit_name: unit -> string (* Read, save a signature to/from a file *) -val read_signature: modname -> filepath -> signature +val read_signature: Unit_info.Artifact.t -> signature (* Arguments: module name, file name. Results: signature. *) val save_signature: - alerts:alerts -> signature -> modname -> filepath + alerts:alerts -> Types.signature -> Unit_info.Artifact.t -> Cmi_format.cmi_infos (* Arguments: signature, module name, file name. *) val save_signature_with_imports: - alerts:alerts -> signature -> modname -> filepath -> crcs + alerts:alerts -> signature -> Unit_info.Artifact.t -> crcs -> Cmi_format.cmi_infos (* Arguments: signature, module name, file name, imported units with their CRCs. *) diff --git a/src/ocaml/typing/envaux.ml b/src/ocaml/typing/envaux.ml index a0bbbc2684..90e0da92c4 100644 --- a/src/ocaml/typing/envaux.ml +++ b/src/ocaml/typing/envaux.ml @@ -77,7 +77,7 @@ let rec env_from_summary sum subst = | Env_constraints(s, map) -> Path.Map.fold (fun path info -> - Env.add_local_type (Subst.type_path subst path) + Env.add_local_constraint (Subst.type_path subst path) (Subst.type_declaration subst info)) map (env_from_summary s subst) | Env_copy_types s -> @@ -102,10 +102,12 @@ let env_of_only_summary env = (* Error report *) open Format +module Style = Misc.Style let report_error ppf = function | Module_not_found p -> - fprintf ppf "@[Cannot find module %a@].@." Printtyp.path p + fprintf ppf "@[Cannot find module %a@].@." + (Style.as_inline_code Printtyp.path) p let () = Location.register_error_of_exn diff --git a/src/ocaml/typing/ident.ml b/src/ocaml/typing/ident.ml index dbd8a038f9..149feff921 100644 --- a/src/ocaml/typing/ident.ml +++ b/src/ocaml/typing/ident.ml @@ -149,6 +149,19 @@ let print_with_scope ppf id = print ~with_scope:true ppf id let print ppf id = print ~with_scope:false ppf id +(* For the documentation of ['a Ident.tbl], see ident.mli. + + The implementation is a copy-paste specialization of + a balanced-tree implementation similar to Map. + ['a tbl] + is a slightly more compact version of + [(Ident.t * 'a) list Map.Make(String)] + + This implementation comes from Caml Light where duplication was + unavoidable in absence of functors. It works well enough, and so + far we have not had strong incentives to do the deduplication work + (implementation, tests, benchmarks, etc.). +*) type 'a tbl = Empty | Node of 'a tbl * 'a data * 'a tbl * int @@ -281,6 +294,21 @@ let rec find_all n = function else find_all n (if c < 0 then l else r) +let get_all_seq k () = + Seq.unfold (Option.map (fun k -> (k.ident, k.data), k.previous)) + k () + +let rec find_all_seq n tbl () = + match tbl with + | Empty -> Seq.Nil + | Node(l, k, r, _) -> + let c = String.compare n (name k.ident) in + if c = 0 then + Seq.Cons((k.ident, k.data), get_all_seq k.previous) + else + find_all_seq n (if c < 0 then l else r) () + + let rec fold_aux f stack accu = function Empty -> begin match stack with diff --git a/src/ocaml/typing/ident.mli b/src/ocaml/typing/ident.mli index 2c04072d44..cfc4ca10b7 100644 --- a/src/ocaml/typing/ident.mli +++ b/src/ocaml/typing/ident.mli @@ -64,13 +64,43 @@ val highest_scope: int val reinit: unit -> unit type 'a tbl - (* Association tables from identifiers to type 'a. *) +(** ['a tbl] represents association tables from identifiers to values + of type ['a]. + + ['a tbl] plays the role of map, but bindings can be looked up + from either the full Ident using [find_same], or just its + user-visible name using [find_name]. In general the two lookups may + not return the same result, as an identifier may have been shadowed + in the environment by a distinct identifier with the same name. + + [find_all] returns the bindings for all idents of a given name, + most recently introduced first. + + In other words, + ['a tbl] + corresponds to + [(Ident.t * 'a) list Map.Make(String)] + and the implementation is very close to that representation. + + Note in particular that searching among idents of the same name + takes linear time, and that [add] simply extends the list without + checking for duplicates. So it is not a good idea to implement + union by repeated [add] calls, which may result in many duplicated + identifiers and poor [find_same] performance. It is even possible + to build overly large same-name lists such that non-recursive + functions like [find_all] or [fold_all] blow the stack. + + You should probably use [Map.Make(Ident)] instead, unless you + really need to query bindings by user-visible name, not just by + unique identifiers. +*) val empty: 'a tbl val add: t -> 'a -> 'a tbl -> 'a tbl val find_same: t -> 'a tbl -> 'a val find_name: string -> 'a tbl -> t * 'a val find_all: string -> 'a tbl -> (t * 'a) list +val find_all_seq: string -> 'a tbl -> (t * 'a) Seq.t val fold_name: (t -> 'a -> 'b -> 'b) -> 'a tbl -> 'b -> 'b val fold_all: (t -> 'a -> 'b -> 'b) -> 'a tbl -> 'b -> 'b val iter: (t -> 'a -> unit) -> 'a tbl -> unit diff --git a/src/ocaml/typing/includeclass.ml b/src/ocaml/typing/includeclass.ml index 3a2cd57694..39f00f9cf5 100644 --- a/src/ocaml/typing/includeclass.ml +++ b/src/ocaml/typing/includeclass.ml @@ -56,12 +56,13 @@ let include_err mode ppf = | CM_Parameter_arity_mismatch _ -> fprintf ppf "The classes do not have the same number of type parameters" - | CM_Type_parameter_mismatch (env, err) -> + | CM_Type_parameter_mismatch (n, env, err) -> Printtyp.report_equality_error ppf mode env err (function ppf -> - fprintf ppf "A type parameter has type") + fprintf ppf "The %d%s type parameter has type" + n (Misc.ordinal_suffix n)) (function ppf -> - fprintf ppf "but is expected to have type") + fprintf ppf "but is expected to have type") | CM_Class_type_mismatch (env, cty1, cty2) -> Printtyp.wrap_printing_env ~error:true env (fun () -> fprintf ppf @@ -69,10 +70,11 @@ let include_err mode ppf = Printtyp.class_type cty1 "is not matched by the class type" Printtyp.class_type cty2) - | CM_Parameter_mismatch (env, err) -> + | CM_Parameter_mismatch (n, env, err) -> Printtyp.report_moregen_error ppf mode env err (function ppf -> - fprintf ppf "A parameter has type") + fprintf ppf "The %d%s parameter has type" + n (Misc.ordinal_suffix n)) (function ppf -> fprintf ppf "but is expected to have type") | CM_Val_type_mismatch (lab, env, err) -> diff --git a/src/ocaml/typing/includecore.ml b/src/ocaml/typing/includecore.ml index 1cfc973134..595c07e935 100644 --- a/src/ocaml/typing/includecore.ml +++ b/src/ocaml/typing/includecore.ml @@ -133,6 +133,20 @@ type privacy_mismatch = | Private_extensible_variant | Private_row_type +type type_kind = + | Kind_abstract + | Kind_record + | Kind_variant + | Kind_open + +let of_kind = function + | Type_abstract _ -> Kind_abstract + | Type_record (_, _) -> Kind_record + | Type_variant (_, _) -> Kind_variant + | Type_open -> Kind_open + +type kind_mismatch = type_kind * type_kind + type label_mismatch = | Type of Errortrace.equality_error | Mutability of position @@ -177,7 +191,7 @@ type variant_change = type type_mismatch = | Arity | Privacy of privacy_mismatch - | Kind + | Kind of kind_mismatch | Constraint of Errortrace.equality_error | Manifest of Errortrace.equality_error | Private_variant of type_expr * type_expr * private_variant_mismatch @@ -188,6 +202,8 @@ type type_mismatch = | Unboxed_representation of position | Immediate of Type_immediacy.Violation.t +module Style = Misc.Style + let report_primitive_mismatch first second ppf err = let pr fmt = Format.fprintf ppf fmt in match (err : primitive_mismatch) with @@ -197,8 +213,9 @@ let report_primitive_mismatch first second ppf err = pr "The syntactic arities of these primitives were not the same.@ \ (They must have the same number of arrows present in the source.)" | No_alloc ord -> - pr "%s primitive is [@@@@noalloc] but %s is not" + pr "%s primitive is %a but %s is not" (String.capitalize_ascii (choose ord first second)) + Style.inline_code "[@@noalloc]" (choose_other ord first second) | Native_name -> pr "The native names of the primitives are not the same" @@ -250,30 +267,34 @@ let report_label_mismatch first second env ppf err = let pp_record_diff first second prefix decl env ppf (x : record_change) = match x with | Delete cd -> - Format.fprintf ppf "%aAn extra field, %s, is provided in %s %s." - prefix x (Ident.name cd.delete.ld_id) first decl + Format.fprintf ppf "%aAn extra field, %a, is provided in %s %s." + prefix x Style.inline_code (Ident.name cd.delete.ld_id) first decl | Insert cd -> - Format.fprintf ppf "%aA field, %s, is missing in %s %s." - prefix x (Ident.name cd.insert.ld_id) first decl + Format.fprintf ppf "%aA field, %a, is missing in %s %s." + prefix x Style.inline_code (Ident.name cd.insert.ld_id) first decl | Change Type {got=lbl1; expected=lbl2; reason} -> Format.fprintf ppf "@[%aFields do not match:@;<1 2>\ %a@ is not the same as:\ @;<1 2>%a@ %a@]" prefix x - Printtyp.label lbl1 - Printtyp.label lbl2 + (Style.as_inline_code Printtyp.label) lbl1 + (Style.as_inline_code Printtyp.label) lbl2 (report_label_mismatch first second env) reason | Change Name n -> - Format.fprintf ppf "%aFields have different names, %s and %s." - prefix x n.got n.expected + Format.fprintf ppf "%aFields have different names, %a and %a." + prefix x + Style.inline_code n.got + Style.inline_code n.expected | Swap sw -> - Format.fprintf ppf "%aFields %s and %s have been swapped." - prefix x sw.first sw.last + Format.fprintf ppf "%aFields %a and %a have been swapped." + prefix x + Style.inline_code sw.first + Style.inline_code sw.last | Move {name; got; expected } -> Format.fprintf ppf - "@[<2>%aField %s has been moved@ from@ position %d@ to %d.@]" - prefix x name expected got + "@[<2>%aField %a has been moved@ from@ position %d@ to %d.@]" + prefix x Style.inline_code name expected got let report_patch pr_diff first second decl env ppf patch = let nl ppf () = Format.fprintf ppf "@," in @@ -316,32 +337,36 @@ let report_constructor_mismatch first second decl env ppf err = let pp_variant_diff first second prefix decl env ppf (x : variant_change) = match x with | Delete cd -> - Format.fprintf ppf "%aAn extra constructor, %s, is provided in %s %s." - prefix x (Ident.name cd.delete.cd_id) first decl + Format.fprintf ppf "%aAn extra constructor, %a, is provided in %s %s." + prefix x Style.inline_code (Ident.name cd.delete.cd_id) first decl | Insert cd -> - Format.fprintf ppf "%aA constructor, %s, is missing in %s %s." - prefix x (Ident.name cd.insert.cd_id) first decl + Format.fprintf ppf "%aA constructor, %a, is missing in %s %s." + prefix x Style.inline_code (Ident.name cd.insert.cd_id) first decl | Change Type {got; expected; reason} -> Format.fprintf ppf "@[%aConstructors do not match:@;<1 2>\ %a@ is not the same as:\ @;<1 2>%a@ %a@]" prefix x - Printtyp.constructor got - Printtyp.constructor expected + (Style.as_inline_code Printtyp.constructor) got + (Style.as_inline_code Printtyp.constructor) expected (report_constructor_mismatch first second decl env) reason | Change Name n -> Format.fprintf ppf - "%aConstructors have different names, %s and %s." - prefix x n.got n.expected + "%aConstructors have different names, %a and %a." + prefix x + Style.inline_code n.got + Style.inline_code n.expected | Swap sw -> Format.fprintf ppf - "%aConstructors %s and %s have been swapped." - prefix x sw.first sw.last + "%aConstructors %a and %a have been swapped." + prefix x + Style.inline_code sw.first + Style.inline_code sw.last | Move {name; got; expected} -> Format.fprintf ppf - "@[<2>%aConstructor %s has been moved@ from@ position %d@ to %d.@]" - prefix x name expected got + "@[<2>%aConstructor %a has been moved@ from@ position %d@ to %d.@]" + prefix x Style.inline_code name expected got let report_extension_constructor_mismatch first second decl env ppf err = let pr fmt = Format.fprintf ppf fmt in @@ -349,25 +374,30 @@ let report_extension_constructor_mismatch first second decl env ppf err = | Constructor_privacy -> pr "Private extension constructor(s) would be revealed." | Constructor_mismatch (id, ext1, ext2, err) -> + let constructor = + Style.as_inline_code (Printtyp.extension_only_constructor id) + in pr "@[Constructors do not match:@;<1 2>%a@ is not the same as:\ @;<1 2>%a@ %a@]" - (Printtyp.extension_only_constructor id) ext1 - (Printtyp.extension_only_constructor id) ext2 + constructor ext1 + constructor ext2 (report_constructor_mismatch first second decl env) err + let report_private_variant_mismatch first second decl env ppf err = let pr fmt = Format.fprintf ppf fmt in + let pp_tag ppf x = Format.fprintf ppf "`%s" x in match (err : private_variant_mismatch) with | Only_outer_closed -> (* It's only dangerous in one direction, so we don't have a position *) pr "%s is private and closed, but %s is not closed" (String.capitalize_ascii second) first | Missing (ord, name) -> - pr "The constructor %s is only present in %s %s." - name (choose ord first second) decl + pr "The constructor %a is only present in %s %s." + Style.inline_code name (choose ord first second) decl | Presence s -> - pr "The tag `%s is present in the %s %s,@ but might not be in the %s" - s second decl first + pr "The tag %a is present in the %s %s,@ but might not be in the %s" + (Style.as_inline_code pp_tag) s second decl first | Incompatible_types_for s -> pr "Types for tag `%s are incompatible" s | Types err -> report_type_inequality env ppf err @@ -375,9 +405,23 @@ let report_private_variant_mismatch first second decl env ppf err = let report_private_object_mismatch env ppf err = let pr fmt = Format.fprintf ppf fmt in match (err : private_object_mismatch) with - | Missing s -> pr "The implementation is missing the method %s" s + | Missing s -> + pr "The implementation is missing the method %a" Style.inline_code s | Types err -> report_type_inequality env ppf err +let report_kind_mismatch first second ppf (kind1, kind2) = + let pr fmt = Format.fprintf ppf fmt in + let kind_to_string = function + | Kind_abstract -> "abstract" + | Kind_record -> "a record" + | Kind_variant -> "a variant" + | Kind_open -> "an extensible variant" in + pr "%s is %s, but %s is %s." + (String.capitalize_ascii first) + (kind_to_string kind1) + second + (kind_to_string kind2) + let report_type_mismatch first second decl env ppf err = let pr fmt = Format.fprintf ppf fmt in pr "@ "; @@ -386,8 +430,8 @@ let report_type_mismatch first second decl env ppf err = pr "They have different arities." | Privacy err -> report_privacy_mismatch ppf err - | Kind -> - pr "Their kinds differ." + | Kind err -> + report_kind_mismatch first second ppf err | Constraint err -> (* This error can come from implicit parameter disagreement or from explicit `constraint`s. Both affect the parameters, hence this choice @@ -688,7 +732,7 @@ let privacy_mismatch env decl1 decl2 = | Type_record _, Type_record _ -> Some Private_record_type | Type_variant _, Type_variant _ -> Some Private_variant_type | Type_open, Type_open -> Some Private_extensible_variant - | Type_abstract, Type_abstract + | Type_abstract _, Type_abstract _ when Option.is_some decl2.type_manifest -> begin match decl1.type_manifest with | Some ty1 -> begin @@ -825,7 +869,7 @@ let type_manifest env ty1 params1 ty2 params2 priv2 kind2 = | _ -> begin let is_private_abbrev_2 = match priv2, kind2 with - | Private, Type_abstract -> begin + | Private, Type_abstract _ -> begin (* Same checks as the [when] guards from above, inverted *) match get_desc ty2' with | Tvariant row -> @@ -884,7 +928,7 @@ let type_declarations ?(equality = false) ~loc env ~mark name in if err <> None then err else let err = match (decl1.type_kind, decl2.type_kind) with - (_, Type_abstract) -> None + (_, Type_abstract _) -> None | (Type_variant (cstrs1, rep1), Type_variant (cstrs2, rep2)) -> if mark then begin let mark usage cstrs = @@ -921,10 +965,10 @@ let type_declarations ?(equality = false) ~loc env ~mark name labels1 labels2 rep1 rep2 | (Type_open, Type_open) -> None - | (_, _) -> Some Kind + | (_, _) -> Some (Kind (of_kind decl1.type_kind, of_kind decl2.type_kind)) in if err <> None then err else - let abstr = decl2.type_kind = Type_abstract && decl2.type_manifest = None in + let abstr = Btype.type_kind_is_abstract decl2 && decl2.type_manifest = None in (* If attempt to assign a non-immediate type (e.g. string) to a type that * must be immediate, then we error *) let err = @@ -952,8 +996,8 @@ let type_declarations ?(equality = false) ~loc env ~mark name (if abstr then (imp co1 co2 && imp cn1 cn2) else if opn || constrained ty then (co1 = co2 && cn1 = cn2) else true) && - let (p1,n1,i1,j1) = get_lower v1 and (p2,n2,i2,j2) = get_lower v2 in - imp abstr (imp p2 p1 && imp n2 n1 && imp i2 i1 && imp j2 j1)) + let (p1,n1,j1) = get_lower v1 and (p2,n2,j2) = get_lower v2 in + imp abstr (imp p2 p1 && imp n2 n1 && imp j2 j1)) decl2.type_params (List.combine decl1.type_variance decl2.type_variance) then None else Some Variance diff --git a/src/ocaml/typing/includecore.mli b/src/ocaml/typing/includecore.mli index be1687b620..50825976ce 100644 --- a/src/ocaml/typing/includecore.mli +++ b/src/ocaml/typing/includecore.mli @@ -43,6 +43,14 @@ type privacy_mismatch = | Private_extensible_variant | Private_row_type +type type_kind = + | Kind_abstract + | Kind_record + | Kind_variant + | Kind_open + +type kind_mismatch = type_kind * type_kind + type label_mismatch = | Type of Errortrace.equality_error | Mutability of position @@ -85,7 +93,7 @@ type private_object_mismatch = type type_mismatch = | Arity | Privacy of privacy_mismatch - | Kind + | Kind of kind_mismatch | Constraint of Errortrace.equality_error | Manifest of Errortrace.equality_error | Private_variant of type_expr * type_expr * private_variant_mismatch diff --git a/src/ocaml/typing/includemod.ml b/src/ocaml/typing/includemod.ml index 27491f609f..b43602c51c 100644 --- a/src/ocaml/typing/includemod.ml +++ b/src/ocaml/typing/includemod.ml @@ -53,6 +53,9 @@ module Error = struct | Anonymous | Named of Path.t | Unit + | Empty_struct + (** For backward compatibility's sake, an empty struct can be implicitly + converted to an unit module *) type ('a,'b) diff = {got:'a; expected:'a; symptom:'b} type 'a core_diff =('a,unit) diff @@ -566,24 +569,28 @@ and functor_param ~in_eq ~loc env ~mark subst param1 param2 = | Ok (cc, _) -> Ok cc | Error err -> Error (Error.Mismatch err) in - let env, subst = - match name1, name2 with - | Some id1, Some id2 -> - Env.add_module id1 Mp_present arg2' env, - Subst.add_module id2 (Path.Pident id1) subst - | None, Some id2 -> - let id1 = Ident.rename id2 in - Env.add_module id1 Mp_present arg2' env, - Subst.add_module id2 (Path.Pident id1) subst - | Some id1, None -> - Env.add_module id1 Mp_present arg2' env, subst - | None, None -> - env, subst - in + let env, subst = equate_one_functor_param subst env arg2' name1 name2 in cc_arg, env, subst | _, _ -> Error (Error.Incompatible_params (param1, param2)), env, subst +and equate_one_functor_param subst env arg2' name1 name2 = + match name1, name2 with + | Some id1, Some id2 -> + (* two matching abstract parameters: we add one identifier to the + environment and record the equality between the two identifiers + in the substitution *) + Env.add_module id1 Mp_present arg2' env, + Subst.add_module id2 (Path.Pident id1) subst + | None, Some id2 -> + let id1 = Ident.rename id2 in + Env.add_module id1 Mp_present arg2' env, + Subst.add_module id2 (Path.Pident id1) subst + | Some id1, None -> + Env.add_module id1 Mp_present arg2' env, subst + | None, None -> + env, subst + and strengthened_modtypes ~in_eq ~loc ~aliasable env ~mark subst mty1 path1 mty2 shape = match mty1, mty2 with @@ -741,6 +748,8 @@ and signature_components ~in_eq ~loc old_env ~mark env subst type_declarations ~loc ~old_env env ~mark subst id1 tydec1 tydec2 in let item = mark_error_as_unrecoverable item in + (* Right now we don't filter hidden constructors / labels from the + shape. *) let shape_map = Shape.Map.add_type_proj shape_map id1 orig_shape in id1, item, shape_map, false | Sig_typext(id1, ext1, _, _), Sig_typext(_id2, ext2, _, _) -> @@ -908,7 +917,7 @@ and check_modtype_equiv ~in_eq ~loc env ~mark mty1 mty2 = let can_alias env path = let rec no_apply = function | Path.Pident _ -> true - | Path.Pdot(p, _) -> no_apply p + | Path.Pdot(p, _) | Path.Pextra_ty (p, _) -> no_apply p | Path.Papply _ -> false in no_apply path && not (Env.is_functor_arg path env) @@ -918,10 +927,14 @@ let can_alias env path = type explanation = Env.t * Error.all exception Error of explanation +type application_name = + | Anonymous_functor + | Full_application_path of Longident.t + | Named_leftmost_functor of Longident.t exception Apply_error of { loc : Location.t ; env : Env.t ; - lid_app : Longident.t option ; + app_name : application_name ; mty_f : module_type ; args : (Error.functor_arg_descr * module_type) list ; } @@ -951,8 +964,8 @@ let check_functor_application_in_path in let mty_f = (Env.find_module f0_path env).md_type in let args = List.map prepare_arg args in - let lid_app = Some lid_whole_app in - raise (Apply_error {loc; env; lid_app; mty_f; args}) + let app_name = Full_application_path lid_whole_app in + raise (Apply_error {loc; env; app_name; mty_f; args}) else raise Not_found @@ -1033,36 +1046,36 @@ module Functor_inclusion_diff = struct | None -> state, [||] | Some (res, expansion) -> { state with res }, expansion - let update (d:Diff.change) st = match d with + (* Whenever we have a named parameter that doesn't match it anonymous + counterpart, we add it to the typing environment because it may + contain useful abbreviations, but without adding any equations *) + let bind id arg state = + let arg' = Subst.modtype Keep state.subst arg in + let env = Env.add_module id Mp_present arg' state.env in + { state with env } + + let rec update (d:Diff.change) st = + match d with | Insert (Unit | Named (None,_)) | Delete (Unit | Named (None,_)) | Keep (Unit,_,_) - | Keep (_,Unit,_) - | Change (_,(Unit | Named (None,_)), _) -> + | Keep (_,Unit,_) -> + (* No named abstract parameters: we keep the same environment *) st, [||] - | Insert (Named (Some id, arg)) - | Delete (Named (Some id, arg)) - | Change (Unit, Named (Some id, arg), _) -> - let arg' = Subst.modtype Keep st.subst arg in - let env = Env.add_module id Mp_present arg' st.env in - expand_params { st with env } - | Keep (Named (name1, _), Named (name2, arg2), _) - | Change (Named (name1, _), Named (name2, arg2), _) -> begin - let arg' = Subst.modtype Keep st.subst arg2 in - match name1, name2 with - | Some id1, Some id2 -> - let env = Env.add_module id1 Mp_present arg' st.env in - let subst = Subst.add_module id2 (Path.Pident id1) st.subst in - expand_params { st with env; subst } - | None, Some id2 -> - let env = Env.add_module id2 Mp_present arg' st.env in - { st with env }, [||] - | Some id1, None -> - let env = Env.add_module id1 Mp_present arg' st.env in - expand_params { st with env } - | None, None -> - st, [||] - end + | Insert (Named (Some id, arg)) | Delete (Named (Some id, arg)) -> + (* one named parameter to bind *) + st |> bind id arg |> expand_params + | Change (delete, insert, _) -> + (* Change should be delete + insert: we add both abstract parameters + to the environment without equating them. *) + let st, _expansion = update (Diffing.Delete delete) st in + update (Diffing.Insert insert) st + | Keep (Named (name1, _), Named (name2, arg2), _) -> + let arg = Subst.modtype Keep st.subst arg2 in + let env, subst = + equate_one_functor_param st.subst st.env arg name1 name2 + in + expand_params { st with env; subst } let diff env (l1,res1) (l2,_) = let module Compute = Diff.Left_variadic(struct @@ -1107,56 +1120,50 @@ module Functor_app_diff = struct begin let desc1 : Error.functor_arg_descr = fst param1 in match desc1, I.param_name param2 with - | (Unit | Anonymous) , None + | (Unit | Empty_struct | Anonymous) , None -> 0 | Named (Path.Pident n1), Some n2 when String.equal (Ident.name n1) (Ident.name n2) -> 0 | Named _, Some _ -> 1 - | Named _, None | (Unit | Anonymous), Some _ -> 1 + | Named _, None | (Unit | Empty_struct | Anonymous), Some _ -> 1 end let update (d: Diff.change) (st:Defs.state) = let open Error in match d with - | Insert _ - | Delete _ - | Keep ((Unit,_),_,_) - | Keep (_,Unit,_) - | Change (_,(Unit | Named (None,_)), _ ) - | Change ((Unit,_), Named (Some _, _), _) -> + | Insert (Unit|Named(None,_)) + | Delete _ (* delete is a concrete argument, not an abstract parameter*) + | Keep ((Unit,_),_,_) (* Keep(Unit,_) implies Keep(Unit,Unit) *) + | Keep (_,(Unit|Named(None,_)),_) + | Change (_,(Unit|Named (None,_)), _ ) -> + (* no abstract parameters to add, nor any equations *) st, [||] - | Keep ((Named arg, _mty) , Named (param_name, _param), _) - | Change ((Named arg, _mty), Named (param_name, _param), _) -> - begin match param_name with - | Some param -> - let res = - Option.map (fun res -> - let scope = Ctype.create_scope () in - let subst = Subst.add_module param arg Subst.identity in - Subst.modtype (Rescope scope) subst res - ) - st.res - in - let subst = Subst.add_module param arg st.subst in - I.expand_params { st with subst; res } - | None -> - st, [||] - end - | Keep ((Anonymous, mty) , Named (param_name, _param), _) - | Change ((Anonymous, mty), Named (param_name, _param), _) -> begin - begin match param_name with - | Some param -> - let mty' = Subst.modtype Keep st.subst mty in - let env = - Env.add_module ~arg:true param Mp_present mty' st.env in - let res = - Option.map (Mtype.nondep_supertype env [param]) st.res in - I.expand_params { st with env; res} - | None -> - st, [||] - end - end + | Insert(Named(Some param, param_ty)) + | Change(_, Named(Some param, param_ty), _ ) -> + (* Change is Delete + Insert: we add the Inserted parameter to the + environment to track equalities with external components that the + parameter might add. *) + let mty = Subst.modtype Keep st.subst param_ty in + let env = Env.add_module ~arg:true param Mp_present mty st.env in + I.expand_params { st with env } + | Keep ((Named arg, _mty) , Named (Some param, _param), _) -> + let res = + Option.map (fun res -> + let scope = Ctype.create_scope () in + let subst = Subst.add_module param arg Subst.identity in + Subst.modtype (Rescope scope) subst res + ) + st.res + in + let subst = Subst.add_module param arg st.subst in + I.expand_params { st with subst; res } + | Keep (((Anonymous|Empty_struct), mty), + Named (Some param, _param), _) -> + let mty' = Subst.modtype Keep st.subst mty in + let env = Env.add_module ~arg:true param Mp_present mty' st.env in + let res = Option.map (Mtype.nondep_supertype env [param]) st.res in + I.expand_params { st with env; res} let diff env ~f ~args = let params, res = retrieve_functor_params env f in @@ -1165,10 +1172,10 @@ module Functor_app_diff = struct let test (state:Defs.state) (arg,arg_mty) param = let loc = Location.none in let res = match (arg:Error.functor_arg_descr), param with - | Unit, Unit -> Ok Tcoerce_none + | (Unit|Empty_struct), Unit -> Ok Tcoerce_none | Unit, Named _ | (Anonymous | Named _), Unit -> Result.Error (Error.Incompatible_params(arg,param)) - | ( Anonymous | Named _ ) , Named (_, param) -> + | ( Anonymous | Named _ | Empty_struct ), Named (_, param) -> match modtypes ~in_eq:false ~loc state.env ~mark:Mark_neither state.subst arg_mty param Shape.dummy_mod diff --git a/src/ocaml/typing/includemod.mli b/src/ocaml/typing/includemod.mli index 8846c4510c..a57d51b67c 100644 --- a/src/ocaml/typing/includemod.mli +++ b/src/ocaml/typing/includemod.mli @@ -43,6 +43,9 @@ module Error: sig | Anonymous | Named of Path.t | Unit + | Empty_struct + (** For backward compatibility's sake, an empty struct can be implicitly + converted to an unit module. *) type core_sigitem_symptom = | Value_descriptions of @@ -212,10 +215,16 @@ type pos = | Body of functor_parameter exception Error of explanation + +type application_name = + | Anonymous_functor (** [(functor (_:sig end) -> struct end)(Int)] *) + | Full_application_path of Longident.t (** [F(G(X).P)(Y)] *) + | Named_leftmost_functor of Longident.t (** [F(struct end)...(...)] *) + exception Apply_error of { loc : Location.t ; env : Env.t ; - lid_app : Longident.t option ; + app_name : application_name ; mty_f : module_type ; args : (Error.functor_arg_descr * Types.module_type) list ; } diff --git a/src/ocaml/typing/includemod_errorprinter.ml b/src/ocaml/typing/includemod_errorprinter.ml index df49a16e29..0ffd000bba 100644 --- a/src/ocaml/typing/includemod_errorprinter.ml +++ b/src/ocaml/typing/includemod_errorprinter.ml @@ -13,6 +13,7 @@ (* *) (**************************************************************************) +module Style = Misc.Style module Context = struct type pos = @@ -63,16 +64,20 @@ module Context = struct let alt_pp ppf cxt = if cxt = [] then () else if List.for_all (function Module _ -> true | _ -> false) cxt then - Format.fprintf ppf "in module %a," Printtyp.path (path_of_context cxt) + Format.fprintf ppf "in module %a," + (Style.as_inline_code Printtyp.path) (path_of_context cxt) else - Format.fprintf ppf "@[at position@ %a,@]" context cxt + Format.fprintf ppf "@[at position@ %a,@]" + (Style.as_inline_code context) cxt let pp ppf cxt = if cxt = [] then () else if List.for_all (function Module _ -> true | _ -> false) cxt then - Format.fprintf ppf "In module %a:@ " Printtyp.path (path_of_context cxt) + Format.fprintf ppf "In module %a:@ " + (Style.as_inline_code Printtyp.path) (path_of_context cxt) else - Format.fprintf ppf "@[At position@ %a@]@ " context cxt + Format.fprintf ppf "@[At position@ %a@]@ " + (Style.as_inline_code context) cxt end module Illegal_permutation = struct @@ -163,9 +168,9 @@ module Illegal_permutation = struct let item mt k = Includemod.item_ident_name (runtime_item k mt) let pp_item ppf (id,_,kind) = - Format.fprintf ppf "%s %S" + Format.fprintf ppf "%s %a" (Includemod.kind_of_field_desc kind) - (Ident.name id) + Style.inline_code (Ident.name id) let pp ctx_printer env ppf (mty,c) = try @@ -339,6 +344,7 @@ module With_shorthand = struct let arg, mty = ua.item in match (arg: Err.functor_arg_descr) with | Unit -> Format.dprintf "()" + | Empty_struct -> Format.dprintf "(struct end)" | Named p -> let mty = modtype { ua with item = mty } in Format.dprintf @@ -357,6 +363,7 @@ module With_shorthand = struct let arg, mty = ua.item in match (arg: Err.functor_arg_descr) with | Unit -> Format.dprintf "()" + | Empty_struct -> Format.dprintf "(struct end)" | Named p -> fun ppf -> Printtyp.path ppf p | Anonymous -> let short_mty = modtype { ua with item=mty } in @@ -377,7 +384,7 @@ module Functor_suberror = struct let elt (x,param) = let sty = Diffing.(style @@ classify x) in Format.dprintf "%a%t%a" - Format.pp_open_stag (Misc.Color.Style sty) + Format.pp_open_stag (Style.Style sty) (printer param) Format.pp_close_stag () in @@ -519,7 +526,10 @@ module Functor_suberror = struct | Named _ | Anonymous -> Format.dprintf "The functor was expected to be generative at this position" - + | Empty_struct -> + (* an empty structure can be used in both applicative and generative + context *) + assert false end let subcase sub ~expansion_token env (pos, diff) = @@ -658,8 +668,9 @@ let core env id x = let missing_field ppf item = let id, loc, kind = Includemod.item_ident_name item in - Format.fprintf ppf "The %s `%a' is required but not provided%a" - (Includemod.kind_of_field_desc kind) Printtyp.ident id + Format.fprintf ppf "The %s %a is required but not provided%a" + (Includemod.kind_of_field_desc kind) + (Style.as_inline_code Printtyp.ident) id (show_loc "Expected declaration") loc let module_types {Err.got=mty1; expected=mty2} = @@ -685,8 +696,8 @@ let module_type_declarations id {Err.got=d1 ; expected=d2} = let interface_mismatch ppf (diff: _ Err.diff) = Format.fprintf ppf - "The implementation %s@ does not match the interface %s:@ " - diff.got diff.expected + "The implementation %a@ does not match the interface %a:@ " + Style.inline_code diff.got Style.inline_code diff.expected let core_module_type_symptom (x:Err.core_module_type_symptom) = match x with @@ -696,7 +707,9 @@ let core_module_type_symptom (x:Err.core_module_type_symptom) = Some Printtyp.Conflicts.print_explanations else None | Unbound_module_path path -> - Some(Format.dprintf "Unbound module %a" Printtyp.path path) + Some(Format.dprintf "Unbound module %a" + (Style.as_inline_code Printtyp.path) path + ) (* Construct a linearized error message from the error tree *) @@ -736,7 +749,8 @@ and module_type_symptom ~eqmode ~expansion_token ~env ~before ~ctx = function module_type ~eqmode ~expansion_token ~env ~before ~ctx diff | Invalid_module_alias path -> let printer = - Format.dprintf "Module %a cannot be aliased" Printtyp.path path + Format.dprintf "Module %a cannot be aliased" + (Style.as_inline_code Printtyp.path) path in dwith_context ctx printer :: before @@ -767,10 +781,11 @@ and functor_symptom ~expansion_token ~env ~before ~ctx = function and signature ~expansion_token ~env:_ ~before ~ctx sgs = Printtyp.wrap_printing_env ~error:true sgs.env (fun () -> match sgs.missings, sgs.incompatibles with - | a :: l , _ -> + | _ :: _ as missings, _ -> if expansion_token then - with_context ctx missing_field a - :: List.map (Location.msg "%a" missing_field) l + let init_missings, last_missing = Misc.split_last missings in + List.map (Location.msg "%a" missing_field) init_missings + @ [ with_context ctx missing_field last_missing ] @ before else before @@ -892,11 +907,7 @@ let report_error err = let main = err_msgs err in Location.errorf ~loc:Location.(in_file !input_name) "%t" main -let report_apply_error ~loc env (lid_app, mty_f, args) = - let may_print_app ppf = match lid_app with - | None -> () - | Some lid -> Format.fprintf ppf "%a " Printtyp.longident lid - in +let report_apply_error ~loc env (app_name, mty_f, args) = let d = Functor_suberror.App.patch env ~f:mty_f ~args in match d with (* We specialize the one change and one argument case to remove the @@ -911,26 +922,57 @@ let report_apply_error ~loc env (lid_app, mty_f, args) = in Location.errorf ~loc "%t" (Functor_suberror.App.single_diff g e more) | _ -> - let actual = Functor_suberror.App.got d in - let expected = Functor_suberror.expected d in - let sub = - List.rev @@ - Functor_suberror.params functor_app_diff env ~expansion_token:true d + let not_functor = + List.for_all (function _, Diffing.Delete _ -> true | _ -> false) d in - Location.errorf ~loc ~sub - "@[The functor application %tis ill-typed.@ \ - These arguments:@;<1 2>\ - @[%t@]@ do not match these parameters:@;<1 2>@[functor@ %t@ -> ...@]@]" - may_print_app - actual expected + if not_functor then + match app_name with + | Includemod.Named_leftmost_functor lid -> + Location.errorf ~loc + "@[The module %a is not a functor, it cannot be applied.@]" + (Style.as_inline_code Printtyp.longident) lid + | Includemod.Anonymous_functor + | Includemod.Full_application_path _ + (* The "non-functor application in term" case is directly handled in + [Env] and it is the only case where we have a full application + path at hand. Thus this case of the or-pattern is currently + unreachable and we don't try to specialize the corresponding error + message. *) -> + Location.errorf ~loc + "@[This module is not a functor, it cannot be applied.@]" + else + let intro ppf = + match app_name with + | Includemod.Anonymous_functor -> + Format.fprintf ppf "This functor application is ill-typed." + | Includemod.Full_application_path lid -> + Format.fprintf ppf "The functor application %a is ill-typed." + (Style.as_inline_code Printtyp.longident) lid + | Includemod.Named_leftmost_functor lid -> + Format.fprintf ppf + "This application of the functor %a is ill-typed." + (Style.as_inline_code Printtyp.longident) lid + in + let actual = Functor_suberror.App.got d in + let expected = Functor_suberror.expected d in + let sub = + List.rev @@ + Functor_suberror.params functor_app_diff env ~expansion_token:true d + in + Location.errorf ~loc ~sub + "@[%t@ \ + These arguments:@;<1 2>@[%t@]@ \ + do not match these parameters:@;<1 2>@[functor@ %t@ -> ...@]@]" + intro + actual expected let register () = Location.register_error_of_exn (function | Includemod.Error err -> Some (report_error err) - | Includemod.Apply_error {loc; env; lid_app; mty_f; args} -> + | Includemod.Apply_error {loc; env; app_name; mty_f; args} -> Some (Printtyp.wrap_printing_env env ~error:true (fun () -> - report_apply_error ~loc env (lid_app, mty_f, args)) + report_apply_error ~loc env (app_name, mty_f, args)) ) | _ -> None ) diff --git a/src/ocaml/typing/lambda.ml b/src/ocaml/typing/lambda.ml new file mode 100644 index 0000000000..7e473d3574 --- /dev/null +++ b/src/ocaml/typing/lambda.ml @@ -0,0 +1,9 @@ +(* The lambda representation is of no interest for Merlin, but some types are + used by [value_rec_check]. *) + +type immediate_or_pointer = + | Immediate + | Pointer + +type array_kind = + Pgenarray | Paddrarray | Pintarray | Pfloatarray diff --git a/src/ocaml/typing/magic_numbers.ml b/src/ocaml/typing/magic_numbers.ml index 386f87993c..f5503f0000 100644 --- a/src/ocaml/typing/magic_numbers.ml +++ b/src/ocaml/typing/magic_numbers.ml @@ -22,14 +22,20 @@ module Cmi = struct | "Caml1999I029" -> Some "4.12" | "Caml1999I030" -> Some "4.13" | "Caml1999I031" -> Some "4.14" + | "Caml1999I032" -> Some "5.0" + | "Caml1999I033" -> Some "5.1" + | "Caml1999I034" -> Some "5.2" | _ -> None + let () = assert (to_version_opt Config.cmi_magic_number <> None) + open Format + module Style = Misc.Style let report_error ppf = function | Not_an_interface filename -> fprintf ppf "%a@ is not a compiled interface" - Location.print_filename filename + (Style.as_inline_code Location.print_filename) filename | Wrong_version_interface (filename, compiler_magic) -> let program_name = Lib_config.program_name () in begin match to_version_opt compiler_magic with @@ -61,7 +67,7 @@ module Cmi = struct end | Corrupted_interface filename -> fprintf ppf "Corrupted compiled interface@ %a" - Location.print_filename filename + (Style.as_inline_code Location.print_filename) filename let () = Location.register_error_of_exn diff --git a/src/ocaml/typing/msupport.ml b/src/ocaml/typing/msupport.ml index 02619389a2..0e59809885 100644 --- a/src/ocaml/typing/msupport.ml +++ b/src/ocaml/typing/msupport.ml @@ -28,7 +28,9 @@ open Std -let errors : (exn list ref * unit Btype.TypeHash.t) option ref = ref None +module RawTypeHash = Hashtbl.Make(Types.TransientTypeOps) + +let errors : (exn list ref * unit RawTypeHash.t) option ref = ref None let monitor_errors' = ref (ref false) let monitor_errors () = @@ -66,7 +68,7 @@ let catch_errors warnings caught f = let warnings' = Warnings.backup () in let errors' = !errors in Warnings.restore warnings; - errors := (Some (caught,Btype.TypeHash.create 3)); + errors := (Some (caught,RawTypeHash.create 3)); Misc.try_finally f ~always:(fun () -> errors := errors'; @@ -78,13 +80,13 @@ let uncatch_errors f = let erroneous_type_register te = let te = Types.Transient_expr.coerce te in match !errors with - | Some (_,h) -> Btype.TypeHash.replace h te () + | Some (_,h) -> RawTypeHash.replace h te () | None -> () let erroneous_type_check te = let te = Types.Transient_expr.coerce te in match !errors with - | Some (_,h) -> Btype.TypeHash.mem h te + | Some (_,h) -> RawTypeHash.mem h te | _ -> false let rec erroneous_expr_check e = diff --git a/src/ocaml/typing/mtype.ml b/src/ocaml/typing/mtype.ml index 3f6a61c047..b12dfde8c4 100644 --- a/src/ocaml/typing/mtype.ml +++ b/src/ocaml/typing/mtype.ml @@ -65,7 +65,7 @@ and strengthen_lazy_sig' ~aliasable env sg p = [] -> [] | (SigL_value(_, _, _) as sigelt) :: rem -> sigelt :: strengthen_lazy_sig' ~aliasable env rem p - | SigL_type(id, {type_kind=Type_abstract}, _, _) :: rem + | SigL_type(id, {type_kind=Type_abstract _}, _, _) :: rem when Btype.is_row_name (Ident.name id) -> strengthen_lazy_sig' ~aliasable env rem p | SigL_type(id, decl, rs, vis) :: rem -> @@ -77,7 +77,7 @@ and strengthen_lazy_sig' ~aliasable env sg p = let manif = Some(Btype.newgenty(Tconstr(Pdot(p, Ident.name id), decl.type_params, ref Mnil))) in - if decl.type_kind = Type_abstract then + if Btype.type_kind_is_abstract decl then { decl with type_private = Public; type_manifest = manif } else { decl with type_manifest = manif } @@ -392,7 +392,7 @@ and contains_type_sig env = List.iter (contains_type_item env) and contains_type_item env = function Sig_type (_,({type_manifest = None} | - {type_kind = Type_abstract; type_private = Private}),_, _) + {type_kind = Type_abstract _; type_private = Private}),_, _) | Sig_modtype _ | Sig_typext (_, {ext_args = Cstr_record _}, _, _) -> (* We consider that extension constructors with an inlined @@ -418,12 +418,12 @@ let contains_type env mty = let rec get_prefixes = function | Pident _ -> Path.Set.empty - | Pdot (p, _) - | Papply (p, _) -> Path.Set.add p (get_prefixes p) + | Pdot (p, _) | Papply (p, _) | Pextra_ty (p, _) + -> Path.Set.add p (get_prefixes p) let rec get_arg_paths = function | Pident _ -> Path.Set.empty - | Pdot (p, _) -> get_arg_paths p + | Pdot (p, _) | Pextra_ty (p, _) -> get_arg_paths p | Papply (p1, p2) -> Path.Set.add p2 (Path.Set.union (get_prefixes p2) @@ -437,6 +437,10 @@ let rec rollback_path subst p = | Pdot (p1, s) -> let p1' = rollback_path subst p1 in if Path.same p1 p1' then p else rollback_path subst (Pdot (p1', s)) + | Pextra_ty (p1, extra) -> + let p1' = rollback_path subst p1 in + if Path.same p1 p1' then p + else rollback_path subst (Pextra_ty (p1', extra)) let rec collect_ids subst bindings p = begin match rollback_path subst p with diff --git a/src/ocaml/typing/oprint.ml b/src/ocaml/typing/oprint.ml index 5950b2f041..57897a19fd 100644 --- a/src/ocaml/typing/oprint.ml +++ b/src/ocaml/typing/oprint.ml @@ -24,6 +24,7 @@ let cautious f ppf arg = let print_lident ppf = function | "::" -> pp_print_string ppf "(::)" + | s when Lexer.is_keyword s -> fprintf ppf "\\#%s" s | s -> pp_print_string ppf s let rec print_ident ppf = @@ -62,6 +63,8 @@ let parenthesized_ident name = let value_ident ppf name = if parenthesized_ident name then fprintf ppf "( %s )" name + else if Lexer.is_keyword name then + fprintf ppf "\\#%s" name else pp_print_string ppf name @@ -153,16 +156,26 @@ let print_out_string ppf s = else fprintf ppf "%S" s +let print_constr ppf name = + match name with + | Oide_ident {printed_name = ("true" | "false") as c} -> + (* despite being keywords, these are constructor names + and should not be escaped *) + fprintf ppf "%s" c + | _ -> print_ident ppf name + let print_out_value ppf tree = let rec print_tree_1 ppf = function | Oval_constr (name, [param]) -> - fprintf ppf "@[<1>%a@ %a@]" print_ident name print_constr_param param + fprintf ppf "@[<1>%a@ %a@]" print_constr name print_constr_param param | Oval_constr (name, (_ :: _ as params)) -> - fprintf ppf "@[<1>%a@ (%a)@]" print_ident name + fprintf ppf "@[<1>%a@ (%a)@]" print_constr name (print_tree_list print_tree_1 ",") params | Oval_variant (name, Some param) -> - fprintf ppf "@[<2>`%s@ %a@]" name print_constr_param param + fprintf ppf "@[<2>`%a@ %a@]" print_lident name print_constr_param param + | Oval_lazy param -> + fprintf ppf "@[<2>lazy@ %a@]" print_constr_param param | tree -> print_simple_tree ppf tree and print_constr_param ppf = function | Oval_int i -> parenthesize_if_neg ppf "%i" i (i < 0) @@ -205,8 +218,8 @@ let print_out_value ppf tree = fprintf ppf "@[<1>[%a]@]" (print_tree_list print_tree_1 ";") tl | Oval_array tl -> fprintf ppf "@[<2>[|%a|]@]" (print_tree_list print_tree_1 ";") tl - | Oval_constr (name, []) -> print_ident ppf name - | Oval_variant (name, None) -> fprintf ppf "`%s" name + | Oval_constr (name, []) -> print_constr ppf name + | Oval_variant (name, None) -> fprintf ppf "`%a" print_lident name | Oval_stuff s -> pp_print_string ppf s | Oval_record fel -> fprintf ppf "@[<1>{%a}@]" (cautious (print_fields true)) fel @@ -255,14 +268,24 @@ let pr_present = print_list (fun ppf s -> fprintf ppf "`%s" s) (fun ppf -> fprintf ppf "@ ") let pr_var = Pprintast.tyvar +let ty_var ~non_gen ppf s = + pr_var ppf (if non_gen then "_" ^ s else s) let pr_vars = print_list pr_var (fun ppf -> fprintf ppf "@ ") +let print_arg_label ppf (lbl : Asttypes.arg_label) = + match lbl with + | Nolabel -> () + | Labelled s -> fprintf ppf "%a:" print_lident s + | Optional s -> fprintf ppf "?%a:" print_lident s + let rec print_out_type ppf = function - | Otyp_alias (ty, s) -> - fprintf ppf "@[%a@ as %a@]" print_out_type ty pr_var s + | Otyp_alias {non_gen; aliased; alias } -> + fprintf ppf "@[%a@ as %a@]" + print_out_type aliased + (ty_var ~non_gen) alias | Otyp_poly (sl, ty) -> fprintf ppf "@[%a.@ %a@]" pr_vars sl @@ -274,7 +297,7 @@ and print_out_type_1 ppf = function Otyp_arrow (lab, ty1, ty2) -> pp_open_box ppf 0; - if lab <> "" then (pp_print_string ppf lab; pp_print_char ppf ':'); + print_arg_label ppf lab; print_out_type_2 ppf ty1; pp_print_string ppf " ->"; pp_print_space ppf (); @@ -288,19 +311,18 @@ and print_out_type_2 ppf = | ty -> print_simple_out_type ppf ty and print_simple_out_type ppf = function - Otyp_class (ng, id, tyl) -> - fprintf ppf "@[%a%s#%a@]" print_typargs tyl (if ng then "_" else "") - print_ident id + Otyp_class (id, tyl) -> + fprintf ppf "@[%a#%a@]" print_typargs tyl print_ident id | Otyp_constr (id, tyl) -> pp_open_box ppf 0; print_typargs ppf tyl; print_ident ppf id; pp_close_box ppf () - | Otyp_object (fields, rest) -> - fprintf ppf "@[<2>< %a >@]" (print_fields rest) fields + | Otyp_object {fields; open_row} -> + fprintf ppf "@[<2>< %a >@]" (print_fields open_row) fields | Otyp_stuff s -> pp_print_string ppf s - | Otyp_var (ng, s) -> pr_var ppf (if ng then "_" ^ s else s) - | Otyp_variant (non_gen, row_fields, closed, tags) -> + | Otyp_var (non_gen, s) -> ty_var ~non_gen ppf s + | Otyp_variant (row_fields, closed, tags) -> let print_present ppf = function None | Some [] -> () @@ -314,8 +336,7 @@ and print_simple_out_type ppf = | Ovar_typ typ -> print_simple_out_type ppf typ in - fprintf ppf "%s@[[%s@[@[%a@]%a@]@ ]@]" - (if non_gen then "_" else "") + fprintf ppf "@[[%s@[@[%a@]%a@]@ ]@]" (if closed then if tags = None then " " else "< " else if tags = None then "> " else "? ") print_fields row_fields @@ -344,29 +365,24 @@ and print_simple_out_type ppf = and print_record_decl ppf lbls = fprintf ppf "{%a@;<1 -2>}" (print_list_init print_out_label (fun ppf -> fprintf ppf "@ ")) lbls -and print_fields rest ppf = +and print_fields open_row ppf = function [] -> - begin match rest with - Some non_gen -> fprintf ppf "%s.." (if non_gen then "_" else "") - | None -> () - end + if open_row then fprintf ppf ".."; | [s, t] -> - fprintf ppf "%s : %a" s print_out_type t; - begin match rest with - Some _ -> fprintf ppf ";@ " - | None -> () - end; - print_fields rest ppf [] + fprintf ppf "%a : %a" print_lident s print_out_type t; + if open_row then fprintf ppf ";@ "; + print_fields open_row ppf [] | (s, t) :: l -> - fprintf ppf "%s : %a;@ %a" s print_out_type t (print_fields rest) l + fprintf ppf "%s : %a;@ %a" s print_out_type t (print_fields open_row) l and print_row_field ppf (l, opt_amp, tyl) = let pr_of ppf = if opt_amp then fprintf ppf " of@ &@ " else if tyl <> [] then fprintf ppf " of@ " else fprintf ppf "" in - fprintf ppf "@[`%s%t%a@]" l pr_of (print_typlist print_out_type " &") + fprintf ppf "@[`%a%t%a@]" print_lident l pr_of + (print_typlist print_out_type " &") tyl and print_typlist print_elem sep ppf = function @@ -389,24 +405,27 @@ and print_typargs ppf = pp_close_box ppf (); pp_print_space ppf () and print_out_label ppf (name, mut, arg) = - fprintf ppf "@[<2>%s%s :@ %a@];" (if mut then "mutable " else "") name + fprintf ppf "@[<2>%s%a :@ %a@];" (if mut then "mutable " else "") + print_lident name print_out_type arg let out_label = ref print_out_label let out_type = ref print_out_type +let out_type_args = ref print_typargs + (* Class types *) -let print_type_parameter ppf s = - if s = "_" then fprintf ppf "_" else pr_var ppf s +let print_type_parameter ?(non_gen=false) ppf s = + if s = "_" then fprintf ppf "_" else ty_var ~non_gen ppf s -let type_parameter ppf (ty, (var, inj)) = +let type_parameter ppf {ot_non_gen=non_gen; ot_name=ty; ot_variance=var,inj} = let open Asttypes in fprintf ppf "%s%s%a" (match var with Covariant -> "+" | Contravariant -> "-" | NoVariance -> "") (match inj with Injective -> "!" | NoInjectivity -> "") - print_type_parameter ty + (print_type_parameter ~non_gen) ty let print_out_class_params ppf = function @@ -427,7 +446,7 @@ let rec print_out_class_type ppf = in fprintf ppf "@[%a%a@]" pr_tyl tyl print_ident id | Octy_arrow (lab, ty, cty) -> - fprintf ppf "@[%s%a ->@ %a@]" (if lab <> "" then lab ^ ":" else "") + fprintf ppf "@[%a%a ->@ %a@]" print_arg_label lab print_out_type_2 ty print_out_class_type cty | Octy_signature (self_ty, csil) -> let pr_param ppf = @@ -444,14 +463,14 @@ and print_out_class_sig_item ppf = fprintf ppf "@[<2>constraint %a =@ %a@]" !out_type ty1 !out_type ty2 | Ocsg_method (name, priv, virt, ty) -> - fprintf ppf "@[<2>method %s%s%s :@ %a@]" + fprintf ppf "@[<2>method %s%s%a :@ %a@]" (if priv then "private " else "") (if virt then "virtual " else "") - name !out_type ty + print_lident name !out_type ty | Ocsg_value (name, mut, vr, ty) -> - fprintf ppf "@[<2>val %s%s%s :@ %a@]" + fprintf ppf "@[<2>val %s%s%a :@ %a@]" (if mut then "mutable " else "") (if vr then "virtual " else "") - name !out_type ty + print_lident name !out_type ty let out_class_type = ref print_out_class_type @@ -592,15 +611,15 @@ and print_out_signature ppf = and print_out_sig_item ppf = function Osig_class (vir_flag, name, params, clt, rs) -> - fprintf ppf "@[<2>%s%s@ %a%s@ :@ %a@]" + fprintf ppf "@[<2>%s%s@ %a%a@ :@ %a@]" (if rs = Orec_next then "and" else "class") (if vir_flag then " virtual" else "") print_out_class_params params - name !out_class_type clt + print_lident name !out_class_type clt | Osig_class_type (vir_flag, name, params, clt, rs) -> - fprintf ppf "@[<2>%s%s@ %a%s@ =@ %a@]" + fprintf ppf "@[<2>%s%s@ %a%a@ =@ %a@]" (if rs = Orec_next then "and" else "class type") (if vir_flag then " virtual" else "") print_out_class_params params - name !out_class_type clt + print_lident name !out_class_type clt | Osig_typext (ext, Oext_exception) -> fprintf ppf "@[<2>exception %a@]" print_out_constr (constructor_of_extension_constructor ext) @@ -651,13 +670,15 @@ and print_out_type_decl kwd ppf td = in let type_defined ppf = match td.otype_params with - [] -> pp_print_string ppf td.otype_name - | [param] -> fprintf ppf "@[%a@ %s@]" type_parameter param td.otype_name + [] -> print_lident ppf td.otype_name + | [param] -> + fprintf ppf "@[%a@ %a@]" type_parameter param + print_lident td.otype_name | _ -> - fprintf ppf "@[(@[%a)@]@ %s@]" + fprintf ppf "@[(@[%a)@]@ %a@]" (print_list type_parameter (fun ppf -> fprintf ppf ",@ ")) td.otype_params - td.otype_name + print_lident td.otype_name in let print_manifest ppf = function @@ -746,17 +767,17 @@ and print_out_constr ppf constr = and print_out_extension_constructor ppf ext = let print_extended_type ppf = match ext.oext_type_params with - [] -> fprintf ppf "%s" ext.oext_type_name + [] -> fprintf ppf "%a" print_lident ext.oext_type_name | [ty_param] -> - fprintf ppf "@[%a@ %s@]" - print_type_parameter + fprintf ppf "@[%a@ %a@]" + (print_type_parameter ~non_gen:false) ty_param - ext.oext_type_name + print_lident ext.oext_type_name | _ -> - fprintf ppf "@[(@[%a)@]@ %s@]" + fprintf ppf "@[(@[%a)@]@ %a@]" (print_list print_type_parameter (fun ppf -> fprintf ppf ",@ ")) ext.oext_type_params - ext.oext_type_name + print_lident ext.oext_type_name in fprintf ppf "@[type %t +=%s@;<1 2>%a@]" print_extended_type @@ -767,16 +788,16 @@ and print_out_extension_constructor ppf ext = and print_out_type_extension ppf te = let print_extended_type ppf = match te.otyext_params with - [] -> fprintf ppf "%s" te.otyext_name + [] -> fprintf ppf "%a" print_lident te.otyext_name | [param] -> - fprintf ppf "@[%a@ %s@]" - print_type_parameter param - te.otyext_name + fprintf ppf "@[%a@ %a@]" + (print_type_parameter ~non_gen:false) param + print_lident te.otyext_name | _ -> - fprintf ppf "@[(@[%a)@]@ %s@]" + fprintf ppf "@[(@[%a)@]@ %a@]" (print_list print_type_parameter (fun ppf -> fprintf ppf ",@ ")) te.otyext_params - te.otyext_name + print_lident te.otyext_name in fprintf ppf "@[type %t +=%s@;<1 2>%a@]" print_extended_type diff --git a/src/ocaml/typing/oprint.mli b/src/ocaml/typing/oprint.mli index baa733d824..31dad9a906 100644 --- a/src/ocaml/typing/oprint.mli +++ b/src/ocaml/typing/oprint.mli @@ -20,6 +20,7 @@ val out_ident : (formatter -> out_ident -> unit) ref val out_value : (formatter -> out_value -> unit) ref val out_label : (formatter -> string * bool * out_type -> unit) ref val out_type : (formatter -> out_type -> unit) ref +val out_type_args : (formatter -> out_type list -> unit) ref val out_constr : (formatter -> out_constructor -> unit) ref val out_class_type : (formatter -> out_class_type -> unit) ref val out_module_type : (formatter -> out_module_type -> unit) ref diff --git a/src/ocaml/typing/outcometree.mli b/src/ocaml/typing/outcometree.mli index b9d03e88b1..ed2b61599c 100644 --- a/src/ocaml/typing/outcometree.mli +++ b/src/ocaml/typing/outcometree.mli @@ -55,25 +55,29 @@ type out_value = | Oval_stuff of string | Oval_tuple of out_value list | Oval_variant of string * out_value option + | Oval_lazy of out_value -type out_type_param = string * (Asttypes.variance * Asttypes.injectivity) +type out_type_param = { + ot_non_gen: bool; + ot_name: string; + ot_variance: Asttypes.variance * Asttypes.injectivity +} type out_type = | Otyp_abstract | Otyp_open - | Otyp_alias of out_type * string - | Otyp_arrow of string * out_type * out_type - | Otyp_class of bool * out_ident * out_type list + | Otyp_alias of {non_gen:bool; aliased:out_type; alias:string} + | Otyp_arrow of Asttypes.arg_label * out_type * out_type + | Otyp_class of out_ident * out_type list | Otyp_constr of out_ident * out_type list | Otyp_manifest of out_type * out_type - | Otyp_object of (string * out_type) list * bool option + | Otyp_object of { fields: (string * out_type) list; open_row:bool} | Otyp_record of (string * bool * out_type) list | Otyp_stuff of string | Otyp_sum of out_constructor list | Otyp_tuple of out_type list | Otyp_var of bool * string - | Otyp_variant of - bool * out_variant * bool * (string list) option + | Otyp_variant of out_variant * bool * (string list) option | Otyp_poly of string list * out_type | Otyp_module of out_ident * (string * out_type) list | Otyp_attribute of out_type * out_attribute @@ -90,7 +94,7 @@ and out_variant = type out_class_type = | Octy_constr of out_ident * out_type list - | Octy_arrow of string * out_type * out_class_type + | Octy_arrow of Asttypes.arg_label * out_type * out_class_type | Octy_signature of out_type option * out_class_sig_item list and out_class_sig_item = | Ocsg_constraint of out_type * out_type diff --git a/src/ocaml/typing/parmatch.ml b/src/ocaml/typing/parmatch.ml index e8ca641410..e10ec777b8 100644 --- a/src/ocaml/typing/parmatch.ml +++ b/src/ocaml/typing/parmatch.ml @@ -20,6 +20,23 @@ open Asttypes open Types open Typedtree +type 'pattern parmatch_case = + { pattern : 'pattern; + has_guard : bool; + needs_refute : bool; + } + +let typed_case { c_lhs; c_guard; c_rhs } = + { pattern = c_lhs; + has_guard = Option.is_some c_guard; + needs_refute = (c_rhs.exp_desc = Texp_unreachable); + } + +let untyped_case { Parsetree.pc_lhs; pc_guard; pc_rhs } = + { pattern = pc_lhs; + has_guard = Option.is_some pc_guard; + needs_refute = (pc_rhs.pexp_desc = Parsetree.Pexp_unreachable); + } (*************************************) (* Utilities for building patterns *) @@ -37,7 +54,8 @@ let omega_list = Patterns.omega_list let extra_pat = make_pat - (Tpat_var (Ident.create_local "+", mknoloc "+")) + (Tpat_var (Ident.create_local "+", mknoloc "+", + Uid.internal_not_actually_unique)) Ctype.none Env.empty @@ -283,8 +301,8 @@ module Compat | ((Tpat_any|Tpat_var _),_) | (_,(Tpat_any|Tpat_var _)) -> true (* Structural induction *) - | Tpat_alias (p,_,_),_ -> compat p q - | _,Tpat_alias (q,_,_) -> compat p q + | Tpat_alias (p,_,_,_),_ -> compat p q + | _,Tpat_alias (q,_,_,_) -> compat p q | Tpat_or (p1,p2,_),_ -> (compat p1 q || compat p2 q) | _,Tpat_or (q1,q2,_) -> @@ -530,12 +548,14 @@ let do_set_args ~erase_mutable q r = match q with end | {pat_desc = Tpat_array omegas} -> let args,rest = read_args omegas r in + let args = if erase_mutable then omegas else args in make_pat (Tpat_array args) q.pat_type q.pat_env:: rest | {pat_desc=Tpat_constant _|Tpat_any} -> q::r (* case any is used in matching.ml *) -| _ -> fatal_error "Parmatch.set_args" +| {pat_desc = (Tpat_var _ | Tpat_alias _ | Tpat_or _); _} -> + fatal_error "Parmatch.set_args" let set_args q r = do_set_args ~erase_mutable:false q r and set_args_erase_mutable q r = do_set_args ~erase_mutable:true q r @@ -823,13 +843,11 @@ let pat_of_constrs ex_pat cstrs = if cstrs = [] then raise Empty else orify_many (List.map (pat_of_constr ex_pat) cstrs) -let pats_of_type ?(always=false) env ty = - let ty' = Ctype.expand_head env ty in - match get_desc ty' with - | Tconstr (path, _, _) -> +let pats_of_type env ty = + match Ctype.extract_concrete_typedecl env ty with + | Typedecl (_, path, {type_kind = Type_variant _ | Type_record _}) -> begin match Env.find_type_descrs path env with - | exception Not_found -> [omega] - | Type_variant (cstrs,_) when always || List.length cstrs <= 1 || + | Type_variant (cstrs,_) when List.length cstrs <= 1 || (* Only explode when all constructors are GADTs *) List.for_all (fun cd -> cd.cstr_generalized) cstrs -> List.map (pat_of_constr (make_pat Tpat_any ty env)) cstrs @@ -840,24 +858,24 @@ let pats_of_type ?(always=false) env ty = labels in [make_pat (Tpat_record (fields, Closed)) ty env] - | Type_variant _ | Type_abstract | Type_open -> [omega] + | _ -> [omega] + end + | Has_no_typedecl -> + begin match get_desc (Ctype.expand_head env ty) with + Ttuple tl -> + [make_pat (Tpat_tuple (omegas (List.length tl))) ty env] + | _ -> [omega] end - | Ttuple tl -> - [make_pat (Tpat_tuple (omegas (List.length tl))) ty env] - | _ -> [omega] + | Typedecl (_, _, {type_kind = Type_abstract _ | Type_open}) + | May_have_typedecl -> [omega] -let rec get_variant_constructors env ty = - match get_desc ty with - | Tconstr (path,_,_) -> begin - try match Env.find_type path env, Env.find_type_descrs path env with - | _, Type_variant (cstrs,_) -> cstrs - | {type_manifest = Some _}, _ -> - get_variant_constructors env - (Ctype.expand_head_once env (clean_copy ty)) +let get_variant_constructors env ty = + match Ctype.extract_concrete_typedecl env ty with + | Typedecl (_, path, {type_kind = Type_variant _}) -> + begin match Env.find_type_descrs path env with + | Type_variant (cstrs,_) -> cstrs | _ -> fatal_error "Parmatch.get_variant_constructors" - with Not_found -> - fatal_error "Parmatch.get_variant_constructors" - end + end | _ -> fatal_error "Parmatch.get_variant_constructors" module ConstructorSet = Set.Make(struct @@ -921,7 +939,8 @@ let build_other ext env = (* let c = {c with cstr_name = "*extension*"} in *) (* PR#7330 *) make_pat (Tpat_var (Ident.create_local "*extension*", - {txt="*extension*"; loc = d.pat_loc})) + {txt="*extension*"; loc = d.pat_loc}, + Uid.internal_not_actually_unique)) Ctype.none Env.empty | Construct _ -> begin match ext with @@ -1051,7 +1070,7 @@ let build_other ext env = let rec has_instance p = match p.pat_desc with | Tpat_variant (l,_,r) when is_absent l r -> false | Tpat_any | Tpat_var _ | Tpat_constant _ | Tpat_variant (_,None,_) -> true - | Tpat_alias (p,_,_) | Tpat_variant (_,Some p,_) -> has_instance p + | Tpat_alias (p,_,_,_) | Tpat_variant (_,Some p,_) -> has_instance p | Tpat_or (p1,p2,_) -> has_instance p1 || has_instance p2 | Tpat_construct (_,_,ps,_) | Tpat_tuple ps | Tpat_array ps -> has_instances ps @@ -1505,7 +1524,7 @@ let is_var_column rs = (* Standard or-args for left-to-right matching *) let rec or_args p = match p.pat_desc with | Tpat_or (p1,p2,_) -> p1,p2 -| Tpat_alias (p,_,_) -> or_args p +| Tpat_alias (p,_,_,_) -> or_args p | _ -> assert false (* Just remove current column *) @@ -1585,7 +1604,7 @@ let extract_columns pss qs = match pss with let rec every_satisfiables pss qs = match qs.active with | [] -> - (* qs is now partitionned, check usefulness *) + (* qs is now partitioned, check usefulness *) begin match qs.ors with | [] -> (* no or-patterns *) if satisfiable (make_matrix pss) (make_vector qs) then @@ -1685,8 +1704,8 @@ and every_both pss qs q1 q2 = let rec le_pat p q = match (p.pat_desc, q.pat_desc) with | (Tpat_var _|Tpat_any),_ -> true - | Tpat_alias(p,_,_), _ -> le_pat p q - | _, Tpat_alias(q,_,_) -> le_pat p q + | Tpat_alias(p,_,_,_), _ -> le_pat p q + | _, Tpat_alias(q,_,_,_) -> le_pat p q | Tpat_constant(c1), Tpat_constant(c2) -> const_compare c1 c2 = 0 | Tpat_construct(_,c1,ps,_), Tpat_construct(_,c2,qs,_) -> Types.equal_tag c1.cstr_tag c2.cstr_tag && le_pats ps qs @@ -1717,6 +1736,10 @@ let get_mins le ps = if List.exists (fun p0 -> le p0 p) ps then select_rec r ps else select_rec (p::r) ps in + (* [select_rec] removes the elements that are followed by a smaller element. + An element that is preceded by a smaller element may stay in the list. + We thus do two passes on the list, which is returned reversed + the first time. *) select_rec [] (select_rec [] ps) (* @@ -1725,8 +1748,8 @@ let get_mins le ps = *) let rec lub p q = match p.pat_desc,q.pat_desc with -| Tpat_alias (p,_,_),_ -> lub p q -| _,Tpat_alias (q,_,_) -> lub p q +| Tpat_alias (p,_,_,_),_ -> lub p q +| _,Tpat_alias (q,_,_,_) -> lub p q | (Tpat_any|Tpat_var _),_ -> q | _,(Tpat_any|Tpat_var _) -> p | Tpat_or (p1,p2,_),_ -> orlub p1 p2 q @@ -1824,8 +1847,8 @@ let pressure_variants_in_computation_pattern tdefs patl = let rec initial_matrix = function [] -> [] - | {c_guard=Some _} :: rem -> initial_matrix rem - | {c_guard=None; c_lhs=p} :: rem -> [p] :: initial_matrix rem + | {has_guard=true} :: rem -> initial_matrix rem + | {has_guard=false; pattern=p} :: rem -> [p] :: initial_matrix rem (* Build up a working pattern matrix by keeping @@ -1833,9 +1856,9 @@ let rec initial_matrix = function *) let rec initial_only_guarded = function | [] -> [] - | { c_guard = None; _} :: rem -> + | { has_guard = false; _} :: rem -> initial_only_guarded rem - | { c_lhs = pat; _ } :: rem -> + | { pattern = pat; _ } :: rem -> [pat] :: initial_only_guarded rem @@ -1843,102 +1866,14 @@ let rec initial_only_guarded = function (* Exhaustiveness check *) (************************) -(* conversion from Typedtree.pattern to Parsetree.pattern list *) -module Conv = struct - open Parsetree - let mkpat desc = Ast_helper.Pat.mk desc - - let name_counter = ref 0 - let fresh name = - let current = !name_counter in - name_counter := !name_counter + 1; - "#$" ^ name ^ Int.to_string current - - let conv typed = - let constrs = Hashtbl.create 7 in - let labels = Hashtbl.create 7 in - let rec loop pat = - match pat.pat_desc with - Tpat_or (pa,pb,_) -> - mkpat (Ppat_or (loop pa, loop pb)) - | Tpat_var (_, ({txt="*extension*"} as nm)) -> (* PR#7330 *) - mkpat (Ppat_var nm) - | Tpat_any - | Tpat_var _ -> - mkpat Ppat_any - | Tpat_constant c -> - mkpat (Ppat_constant (Untypeast.constant c)) - | Tpat_alias (p,_,_) -> loop p - | Tpat_tuple lst -> - mkpat (Ppat_tuple (List.map loop lst)) - | Tpat_construct (cstr_lid, cstr, lst, _) -> - let id = fresh cstr.cstr_name in - let lid = { cstr_lid with txt = Longident.Lident id } in - Hashtbl.add constrs id cstr; - let arg = - match List.map loop lst with - | [] -> None - | [p] -> Some ([], p) - | lst -> Some ([], mkpat (Ppat_tuple lst)) - in - mkpat (Ppat_construct(lid, arg)) - | Tpat_variant(label,p_opt,_row_desc) -> - let arg = Option.map loop p_opt in - mkpat (Ppat_variant(label, arg)) - | Tpat_record (subpatterns, _closed_flag) -> - let fields = - List.map - (fun (_, lbl, p) -> - let id = fresh lbl.lbl_name in - Hashtbl.add labels id lbl; - (mknoloc (Longident.Lident id), loop p)) - subpatterns - in - mkpat (Ppat_record (fields, Open)) - | Tpat_array lst -> - mkpat (Ppat_array (List.map loop lst)) - | Tpat_lazy p -> - mkpat (Ppat_lazy (loop p)) - in - let ps = loop typed in - (ps, constrs, labels) -end - - (* Whether the counter-example contains an extension pattern *) let contains_extension pat = exists_pattern (function - | {pat_desc=Tpat_var (_, {txt="*extension*"})} -> true + | {pat_desc=Tpat_var (_, {txt="*extension*"}, _)} -> true | _ -> false) pat -(* Build a pattern from its expected type *) -type pat_explosion = PE_single | PE_gadt_cases -type ppat_of_type = - | PT_empty - | PT_any - | PT_pattern of - pat_explosion * - Parsetree.pattern * - (string, constructor_description) Hashtbl.t * - (string, label_description) Hashtbl.t - -let ppat_of_type env ty = - match pats_of_type env ty with - | [] -> PT_empty - | [{pat_desc = Tpat_any}] -> PT_any - | [pat] -> - let (ppat, constrs, labels) = Conv.conv pat in - PT_pattern (PE_single, ppat, constrs, labels) - | pats -> - let (ppat, constrs, labels) = Conv.conv (orify_many pats) in - PT_pattern (PE_gadt_cases, ppat, constrs, labels) - -let typecheck ~pred p = - let (pattern,constrs,labels) = Conv.conv p in - pred constrs labels pattern - let do_check_partial ~pred loc casel pss = match pss with | [] -> (* @@ -1958,8 +1893,7 @@ let do_check_partial ~pred loc casel pss = match pss with Partial | ps::_ -> let counter_examples = - exhaust None pss (List.length ps) - |> Seq.filter_map (typecheck ~pred) in + exhaust None pss (List.length ps) |> Seq.filter_map pred in match counter_examples () with | Seq.Nil -> Total | Seq.Cons (v, _rest) -> @@ -1968,7 +1902,7 @@ let do_check_partial ~pred loc casel pss = match pss with try let buf = Buffer.create 16 in let fmt = Format.formatter_of_buffer buf in - Printpat.top_pretty fmt v; + Format.fprintf fmt "%a@?" Printpat.pretty_pat v; if do_match (initial_only_guarded casel) [v] then Buffer.add_string buf "\n(However, some guarded clause may match this value.)"; @@ -2021,7 +1955,8 @@ let rec collect_paths_from_pat r p = match p.pat_desc with List.fold_left (fun r (_, _, p) -> collect_paths_from_pat r p) r lps -| Tpat_variant (_, Some p, _) | Tpat_alias (p,_,_) -> collect_paths_from_pat r p +| Tpat_variant (_, Some p, _) | Tpat_alias (p,_,_,_) -> + collect_paths_from_pat r p | Tpat_or (p1,p2,_) -> collect_paths_from_pat (collect_paths_from_pat r p1) p2 | Tpat_lazy p @@ -2039,7 +1974,7 @@ let rec collect_paths_from_pat r p = match p.pat_desc with let do_check_fragile loc casel pss = let exts = List.fold_left - (fun r c -> collect_paths_from_pat r c.c_lhs) + (fun r c -> collect_paths_from_pat r c.pattern) [] casel in match exts with | [] -> () @@ -2063,10 +1998,10 @@ let do_check_fragile loc casel pss = let check_unused pred casel = if Warnings.is_active Warnings.Redundant_case - || List.exists (fun c -> c.c_rhs.exp_desc = Texp_unreachable) casel then + || List.exists (fun vc -> vc.needs_refute) casel then let rec do_rec pref = function | [] -> () - | {c_lhs=q; c_guard; c_rhs} :: rem -> + | {pattern=q; has_guard; needs_refute=refute} :: rem -> let qs = [q] in begin try let pss = @@ -2077,7 +2012,6 @@ let check_unused pred casel = |> get_mins le_pats in (* First look for redundant or partially redundant patterns *) let r = every_satisfiables (make_rows pss) (make_row qs) in - let refute = (c_rhs.exp_desc = Texp_unreachable) in (* Do not warn for unused [pat -> .] *) if r = Unused && refute then () else let r = @@ -2102,9 +2036,8 @@ let check_unused pred casel = List.map (function [u] -> u | _ -> assert false) sfs in let u = orify_many sfs in (*Format.eprintf "%a@." pretty_val u;*) - let (pattern,constrs,labels) = Conv.conv u in - let pattern = {pattern with Parsetree.ppat_loc = q.pat_loc} in - match pred refute constrs labels pattern with + let pattern = {u with pat_loc = q.pat_loc} in + match pred refute pattern with None when not refute -> Location.prerr_warning q.pat_loc Warnings.Unreachable_case; Used @@ -2124,7 +2057,7 @@ let check_unused pred casel = with Empty | Not_found -> assert false end ; - if c_guard <> None then + if has_guard then do_rec pref rem else do_rec ([q]::pref) rem in @@ -2149,13 +2082,13 @@ let inactive ~partial pat = true | Tpat_constant c -> begin match c with - | Const_string _ -> Config.safe_string + | Const_string _ | Const_int _ | Const_char _ | Const_float _ | Const_int32 _ | Const_int64 _ | Const_nativeint _ -> true end | Tpat_tuple ps | Tpat_construct (_, _, ps, _) -> List.for_all (fun p -> loop p) ps - | Tpat_alias (p,_,_) | Tpat_variant (_, Some p, _) -> + | Tpat_alias (p,_,_,_) | Tpat_variant (_, Some p, _) -> loop p | Tpat_record (ldps,_) -> List.for_all @@ -2274,9 +2207,9 @@ type amb_row = { row : pattern list ; varsets : Ident.Set.t list; } let simplify_head_amb_pat head_bound_variables varsets ~add_column p ps k = let rec simpl head_bound_variables varsets p ps k = match (Patterns.General.view p).pat_desc with - | `Alias (p,x,_) -> + | `Alias (p,x,_,_) -> simpl (Ident.Set.add x head_bound_variables) varsets p ps k - | `Var (x, _) -> + | `Var (x,_,_) -> simpl (Ident.Set.add x head_bound_variables) varsets Patterns.omega ps k | `Or (p1,p2,_) -> simpl head_bound_variables varsets p1 ps @@ -2404,52 +2337,17 @@ let pattern_stable_vars ns p = (* All identifier paths that appear in an expression that occurs as a clause right hand side or guard. - - The function is rather complex due to the compilation of - unpack patterns by introducing code in rhs expressions - and **guards**. - - For pattern (module M:S) -> e the code is - let module M_mod = unpack M .. in e - - Hence M is "free" in e iff M_mod is free in e. - - Not doing so will yield excessive warning in - (module (M:S) } ...) when true -> .... - as M is always present in - let module M_mod = unpack M .. in true *) let all_rhs_idents exp = let ids = ref Ident.Set.empty in -(* Very hackish, detect unpack pattern compilation - and perform "indirect check for them" *) - let is_unpack exp = - List.exists - (fun attr -> attr.Parsetree.attr_name.txt = "#modulepat") - exp.exp_attributes in let open Tast_iterator in let expr_iter iter exp = - (match exp.exp_desc with - | Texp_ident (path, _lid, _descr) -> + match exp.exp_desc with + | Texp_ident (path, _lid, _descr) -> List.iter (fun id -> ids := Ident.Set.add id !ids) (Path.heads path) - (* Use default iterator methods for rest of match.*) - | _ -> Tast_iterator.default_iterator.expr iter exp); - - if is_unpack exp then begin match exp.exp_desc with - | Texp_letmodule - (id_mod,_,_, - {mod_desc= - Tmod_unpack ({exp_desc=Texp_ident (Path.Pident id_exp,_,_)},_)}, - _) -> - assert (Ident.Set.mem id_exp !ids) ; - begin match id_mod with - | Some id_mod when not (Ident.Set.mem id_mod !ids) -> - ids := Ident.Set.remove id_exp !ids - | _ -> () - end - | _ -> assert false - end + (* Use default iterator methods for rest of match.*) + | _ -> Tast_iterator.default_iterator.expr iter exp in let iterator = {Tast_iterator.default_iterator with expr = expr_iter} in iterator.expr iterator exp; @@ -2462,7 +2360,7 @@ let check_ambiguous_bindings = if is_active warn0 then let check_case ns case = match case with | { c_lhs = p; c_guard=None ; _} -> [p]::ns - | { c_lhs=p; c_guard=Some g; _} -> + | { c_lhs = p; c_guard=Some g; _} -> let all = Ident.Set.inter (pattern_vars p) (all_rhs_idents g) in if not (Ident.Set.is_empty all) then begin @@ -2481,27 +2379,21 @@ let check_ambiguous_bindings = in ignore (List.fold_left check_case [] cases) -let do_complete_partial ?pred pss = +let do_complete_partial ~(pred : pattern -> pattern option) pss = (* c/p of [do_check_partial] without the parts concerning the generation of the error message or the warning emiting. *) match pss with | [] -> [] | ps :: _ -> let typecheck p = - match pred with - | Some pred -> - let (pattern,constrs,labels) = Conv.conv p in - Option.map (fun v -> v, Some (constrs, labels)) - (pred constrs labels pattern) - | None -> Some (p, None) + pred p in exhaust None pss (List.length ps) |> Seq.filter_map typecheck |> List.of_seq -let complete_partial ~pred pss = +let complete_partial ~(pred : pattern -> pattern option) pss = let pss = get_mins le_pats pss in - do_complete_partial ~pred pss let return_unused casel = diff --git a/src/ocaml/typing/parmatch.mli b/src/ocaml/typing/parmatch.mli index f0ff75fc84..246ca209ea 100644 --- a/src/ocaml/typing/parmatch.mli +++ b/src/ocaml/typing/parmatch.mli @@ -19,6 +19,24 @@ open Asttypes open Typedtree open Types +(** Most checks in this file need not access all information about a case, + and just need a few pieces of information. [parmatch_case] is those + few pieces of information. +*) +type 'pattern parmatch_case = + { pattern : 'pattern; + has_guard : bool; + needs_refute : bool; + (** true if the program text claims the case is unreachable, a la + [function _ -> .] + *) + } + +type 'category typed_case := 'category general_pattern parmatch_case + +val typed_case : 'category case -> 'category typed_case +val untyped_case : Parsetree.case -> Parsetree.pattern parmatch_case + val const_compare : constant -> constant -> int (** [const_compare c1 c2] compares the actual values represented by [c1] and [c2], while simply using [Stdlib.compare] would compare the @@ -71,28 +89,18 @@ val complete_constrs : constructor_description list -> constructor_description list -(** [ppat_of_type] builds an untyped pattern from its expected type, +(** [pats_of_type] builds a list of patterns from a given expected type, for explosion of wildcard patterns in Typecore.type_pat. There are four interesting cases: - - the type is empty ([PT_empty]) - - no further explosion is necessary ([PT_any]) + - the type is empty ([]) + - no further explosion is necessary ([Pat_any]) - a single pattern is generated, from a record or tuple type - or a single-variant type ([PE_single]) - - an or-pattern is generated, in the case that all branches - are GADT constructors ([PE_gadt_cases]). + or a single-variant type ([tp]) + - a list of patterns, in the case that all branches + are GADT constructors ([tp1; ..; tpn]). *) -type pat_explosion = PE_single | PE_gadt_cases -type ppat_of_type = - | PT_empty - | PT_any - | PT_pattern of - pat_explosion * - Parsetree.pattern * - (string, constructor_description) Hashtbl.t * - (string, label_description) Hashtbl.t - -val ppat_of_type: Env.t -> type_expr -> ppat_of_type +val pats_of_type : Env.t -> type_expr -> pattern list val pressure_variants: Env.t -> pattern list -> unit @@ -107,16 +115,11 @@ val pressure_variants_in_computation_pattern: [refute] indicates that [check_unused] was called on a refutation clause. *) val check_partial: - ((string, constructor_description) Hashtbl.t -> - (string, label_description) Hashtbl.t -> - Parsetree.pattern -> pattern option) -> - Location.t -> value case list -> partial + (pattern -> pattern option) -> Location.t -> value typed_case list + -> partial + val check_unused: - (bool -> - (string, constructor_description) Hashtbl.t -> - (string, label_description) Hashtbl.t -> - Parsetree.pattern -> pattern option) -> - value case list -> unit + (bool -> pattern -> pattern option) -> value typed_case list -> unit (* Irrefutability tests *) val irrefutable : pattern -> bool @@ -127,7 +130,7 @@ val irrefutable : pattern -> bool active. *) val inactive : partial:partial -> pattern -> bool -(* Ambiguous bindings *) +(* Ambiguous bindings. *) val check_ambiguous_bindings : value case list -> unit (* The tag used for open polymorphic variant types with an abstract row *) @@ -138,12 +141,9 @@ val some_private_tag : label (*******************) val complete_partial : - pred:((label, constructor_description) Hashtbl.t -> - (label, label_description) Hashtbl.t -> - Parsetree.pattern -> pattern option) -> + pred:(pattern -> pattern option) -> pattern list list -> - (pattern * ((label, constructor_description) Hashtbl.t * - (label, label_description) Hashtbl.t) option) list + (pattern) list val return_unused: pattern list -> [ `Unused of pattern | `Unused_subs of pattern * pattern list ] list diff --git a/src/ocaml/typing/path.ml b/src/ocaml/typing/path.ml index 4190c27e6a..4b44b0b2f0 100644 --- a/src/ocaml/typing/path.ml +++ b/src/ocaml/typing/path.ml @@ -17,14 +17,25 @@ type t = Pident of Ident.t | Pdot of t * string | Papply of t * t + | Pextra_ty of t * extra_ty +and extra_ty = + | Pcstr_ty of string + | Pext_ty let rec same p1 p2 = p1 == p2 || match (p1, p2) with (Pident id1, Pident id2) -> Ident.same id1 id2 - | (Pdot(p1, s1), Pdot(p2, s2)) -> s1 = s2 && same p1 p2 + | (Pdot(p1, s1), Pdot(p2, s2)) -> + s1 = s2 && same p1 p2 | (Papply(fun1, arg1), Papply(fun2, arg2)) -> - same fun1 fun2 && same arg1 arg2 + same fun1 fun2 && same arg1 arg2 + | (Pextra_ty (p1, t1), Pextra_ty (p2, t2)) -> + let same_extra = match t1, t2 with + | (Pcstr_ty s1, Pcstr_ty s2) -> s1 = s2 + | (Pext_ty, Pext_ty) -> true + | ((Pcstr_ty _ | Pext_ty), _) -> false + in same_extra && same p1 p2 | (_, _) -> false let rec compare p1 p2 = @@ -37,16 +48,35 @@ let rec compare p1 p2 = | (Papply(fun1, arg1), Papply(fun2, arg2)) -> let h = compare fun1 fun2 in if h <> 0 then h else compare arg1 arg2 - | ((Pident _ | Pdot _), (Pdot _ | Papply _)) -> -1 - | ((Pdot _ | Papply _), (Pident _ | Pdot _)) -> 1 + | (Pextra_ty (p1, t1), Pextra_ty (p2, t2)) -> + let h = compare_extra t1 t2 in + if h <> 0 then h else compare p1 p2 + | (Pident _, (Pdot _ | Papply _ | Pextra_ty _)) + | (Pdot _, (Papply _ | Pextra_ty _)) + | (Papply _, Pextra_ty _) + -> -1 + | ((Pextra_ty _ | Papply _ | Pdot _), Pident _) + | ((Pextra_ty _ | Papply _) , Pdot _) + | (Pextra_ty _, Papply _) + -> 1 +and compare_extra t1 t2 = + match (t1, t2) with + Pcstr_ty s1, Pcstr_ty s2 -> String.compare s1 s2 + | (Pext_ty, Pext_ty) + -> 0 + | (Pcstr_ty _, Pext_ty) + -> -1 + | (Pext_ty, Pcstr_ty _) + -> 1 let rec find_free_opt ids = function Pident id -> List.find_opt (Ident.same id) ids - | Pdot(p, _s) -> find_free_opt ids p - | Papply(p1, p2) -> + | Pdot(p, _) | Pextra_ty (p, _) -> find_free_opt ids p + | Papply(p1, p2) -> begin match find_free_opt ids p1 with | None -> find_free_opt ids p2 | Some _ as res -> res + end let exists_free ids p = match find_free_opt ids p with @@ -55,71 +85,60 @@ let exists_free ids p = let rec scope = function Pident id -> Ident.scope id - | Pdot(p, _s) -> scope p + | Pdot(p, _) | Pextra_ty (p, _) -> scope p | Papply(p1, p2) -> Int.max (scope p1) (scope p2) let kfalse _ = false +let maybe_escape s = + if Lexer.is_keyword s then "\\#" ^ s else s + let rec name ?(paren=kfalse) = function - Pident id -> Ident.name id - | Pdot(p, s) -> + Pident id -> maybe_escape (Ident.name id) + | Pdot(p, s) | Pextra_ty (p, Pcstr_ty s) -> + let s = maybe_escape s in name ~paren p ^ if paren s then ".( " ^ s ^ " )" else "." ^ s | Papply(p1, p2) -> name ~paren p1 ^ "(" ^ name ~paren p2 ^ ")" + | Pextra_ty (p, Pext_ty) -> name ~paren p let rec print ppf = function | Pident id -> Ident.print_with_scope ppf id - | Pdot(p, s) -> Format.fprintf ppf "%a.%s" print p s + | Pdot(p, s) | Pextra_ty (p, Pcstr_ty s) -> + Format.fprintf ppf "%a.%s" print p s | Papply(p1, p2) -> Format.fprintf ppf "%a(%a)" print p1 print p2 + | Pextra_ty (p, Pext_ty) -> print ppf p let rec head = function Pident id -> id - | Pdot(p, _s) -> head p + | Pdot(p, _) | Pextra_ty (p, _) -> head p | Papply _ -> assert false let flatten = let rec flatten acc = function | Pident id -> `Ok (id, acc) - | Pdot (p, s) -> flatten (s :: acc) p + | Pdot (p, s) | Pextra_ty (p, Pcstr_ty s) -> flatten (s :: acc) p | Papply _ -> `Contains_apply + | Pextra_ty (p, Pext_ty) -> flatten acc p in fun t -> flatten [] t let heads p = let rec heads p acc = match p with | Pident id -> id :: acc - | Pdot (p, _s) -> heads p acc + | Pdot (p, _) | Pextra_ty (p, _) -> heads p acc | Papply(p1, p2) -> heads p1 (heads p2 acc) in heads p [] let rec last = function | Pident id -> Ident.name id - | Pdot(_, s) -> s - | Papply(_, p) -> last p - -let is_uident s = - assert (s <> ""); - match s.[0] with - | 'A'..'Z' -> true - | _ -> false - -type typath = - | Regular of t - | Ext of t * string - | LocalExt of Ident.t - | Cstr of t * string - -let constructor_typath = function - | Pident id when is_uident (Ident.name id) -> LocalExt id - | Pdot(ty_path, s) when is_uident s -> - if is_uident (last ty_path) then Ext (ty_path, s) - else Cstr (ty_path, s) - | p -> Regular p + | Pdot(_, s) | Pextra_ty (_, Pcstr_ty s) -> s + | Papply(_, p) | Pextra_ty (p, Pext_ty) -> last p let is_constructor_typath p = - match constructor_typath p with - | Regular _ -> false - | _ -> true + match p with + | Pident _ | Pdot _ | Papply _ -> false + | Pextra_ty _ -> true module T = struct type nonrec t = t diff --git a/src/ocaml/typing/path.mli b/src/ocaml/typing/path.mli index bddf9d670a..39e76a3727 100644 --- a/src/ocaml/typing/path.mli +++ b/src/ocaml/typing/path.mli @@ -16,12 +16,49 @@ (* Access paths *) type t = - Pident of Ident.t + | Pident of Ident.t + (** Examples: x, List, int *) | Pdot of t * string + (** Examples: List.map, Float.Array *) | Papply of t * t + (** Examples: Set.Make(Int), Map.Make(Set.Make(Int)) *) + | Pextra_ty of t * extra_ty + (** [Pextra_ty (p, extra)] are additional paths of types + introduced by specific OCaml constructs. See below. + *) +and extra_ty = + | Pcstr_ty of string + (** [Pextra_ty (p, Pcstr_ty c)] is the type of the inline record for + constructor [c] inside type [p]. + + For example, in + {[ + type 'a t = Nil | Cons of {hd : 'a; tl : 'a t} + ]} + + The inline record type [{hd : 'a; tl : 'a t}] cannot + be named by the user in the surface syntax, but internally + it has the path + [Pextra_ty (Pident `t`, Pcstr_ty "Cons")]. + *) + | Pext_ty + (** [Pextra_ty (p, Pext_ty)] is the type of the inline record for + the extension constructor [p]. + + For example, in + {[ + type exn += Error of {loc : loc; msg : string} + ]} + + The inline record type [{loc : loc; msg : string}] cannot + be named by the user in the surface syntax, but internally + it has the path + [Pextra_ty (Pident `Error`, Pext_ty)]. + *) val same: t -> t -> bool val compare: t -> t -> int +val compare_extra: extra_ty -> extra_ty -> int val find_free_opt: Ident.t list -> t -> Ident.t option val exists_free: Ident.t list -> t -> bool val scope: t -> int @@ -37,15 +74,6 @@ val heads: t -> Ident.t list val last: t -> string -val is_uident: string -> bool - -type typath = - | Regular of t - | Ext of t * string - | LocalExt of Ident.t - | Cstr of t * string - -val constructor_typath: t -> typath val is_constructor_typath: t -> bool module Map : Map.S with type key = t diff --git a/src/ocaml/typing/patterns.ml b/src/ocaml/typing/patterns.ml index 55f9d4ff43..456f8dff33 100644 --- a/src/ocaml/typing/patterns.ml +++ b/src/ocaml/typing/patterns.ml @@ -79,18 +79,18 @@ end module General = struct type view = [ | Half_simple.view - | `Var of Ident.t * string loc - | `Alias of pattern * Ident.t * string loc + | `Var of Ident.t * string loc * Uid.t + | `Alias of pattern * Ident.t * string loc * Uid.t ] type pattern = view pattern_data let view_desc = function | Tpat_any -> `Any - | Tpat_var (id, str) -> - `Var (id, str) - | Tpat_alias (p, id, str) -> - `Alias (p, id, str) + | Tpat_var (id, str, uid) -> + `Var (id, str, uid) + | Tpat_alias (p, id, str, uid) -> + `Alias (p, id, str, uid) | Tpat_constant cst -> `Constant cst | Tpat_tuple ps -> @@ -110,8 +110,8 @@ module General = struct let erase_desc = function | `Any -> Tpat_any - | `Var (id, str) -> Tpat_var (id, str) - | `Alias (p, id, str) -> Tpat_alias (p, id, str) + | `Var (id, str, uid) -> Tpat_var (id, str, uid) + | `Alias (p, id, str, uid) -> Tpat_alias (p, id, str, uid) | `Constant cst -> Tpat_constant cst | `Tuple ps -> Tpat_tuple ps | `Construct (cstr, cst_descr, args) -> @@ -129,7 +129,7 @@ module General = struct let rec strip_vars (p : pattern) : Half_simple.pattern = match p.pat_desc with - | `Alias (p, _, _) -> strip_vars (view p) + | `Alias (p, _, _, _) -> strip_vars (view p) | `Var _ -> { p with pat_desc = `Any } | #Half_simple.view as view -> { p with pat_desc = view } end diff --git a/src/ocaml/typing/patterns.mli b/src/ocaml/typing/patterns.mli index 66dd2d05a4..2ad645b0d0 100644 --- a/src/ocaml/typing/patterns.mli +++ b/src/ocaml/typing/patterns.mli @@ -65,8 +65,8 @@ end module General : sig type view = [ | Half_simple.view - | `Var of Ident.t * string loc - | `Alias of pattern * Ident.t * string loc + | `Var of Ident.t * string loc * Uid.t + | `Alias of pattern * Ident.t * string loc * Uid.t ] type pattern = view pattern_data diff --git a/src/ocaml/typing/persistent_env.ml b/src/ocaml/typing/persistent_env.ml index 9b28a17791..a75b4f3e11 100644 --- a/src/ocaml/typing/persistent_env.ml +++ b/src/ocaml/typing/persistent_env.ml @@ -27,7 +27,6 @@ type error = | Illegal_renaming of modname * modname * filepath | Inconsistent_import of modname * filepath * filepath | Need_recursive_types of modname - | Depend_on_unsafe_string_unit of modname exception Error of error let error err = raise (Error err) @@ -35,14 +34,19 @@ let error err = raise (Error err) module Persistent_signature = struct type t = { filename : string; - cmi : Cmi_format.cmi_infos } - - let load = ref (fun ~unit_name -> - match Load_path.find_uncap (unit_name ^ ".cmi") with - | filename -> - let cmi = Cmi_cache.read filename in - Some { filename; cmi } - | exception Not_found -> None) + cmi : Cmi_format.cmi_infos; + visibility : Load_path.visibility } + + let load = ref (fun ~allow_hidden ~unit_name -> + match Load_path.find_normalized_with_visibility (unit_name ^ ".cmi") with + | filename, visibility when allow_hidden -> + let cmi = Cmi_cache.read filename in + Some { filename; cmi; visibility} + | filename, Visible -> + let cmi = Cmi_cache.read filename in + Some { filename; cmi; visibility = Visible} + | _, Hidden + | exception Not_found -> None) end type can_load_cmis = @@ -54,6 +58,7 @@ type pers_struct = { ps_crcs: (string * Digest.t option) list; ps_filename: string; ps_flags: pers_flags list; + ps_visibility: Load_path.visibility; } module String = Misc.String @@ -199,14 +204,13 @@ let save_pers_struct penv crc ps pm = (function | Rectypes -> () | Alerts _ -> () - | Unsafe_string -> () | Opaque -> register_import_as_opaque penv modname) ps.ps_flags; - Consistbl.set crc_units modname crc ps.ps_filename; + Consistbl.check crc_units modname crc ps.ps_filename; add_import penv modname let acknowledge_pers_struct penv short_path_comps check modname pers_sig pm = - let { Persistent_signature.filename; cmi } = pers_sig in + let { Persistent_signature.filename; cmi; visibility } = pers_sig in let name = cmi.cmi_name in let crcs = cmi.cmi_crcs in let flags = cmi.cmi_flags in @@ -214,6 +218,7 @@ let acknowledge_pers_struct penv short_path_comps check modname pers_sig pm = ps_crcs = crcs; ps_filename = filename; ps_flags = flags; + ps_visibility = visibility; } in if ps.ps_name <> modname then error (Illegal_renaming(modname, ps.ps_name, filename)); @@ -222,9 +227,6 @@ let acknowledge_pers_struct penv short_path_comps check modname pers_sig pm = | Rectypes -> if not !Clflags.recursive_types then error (Need_recursive_types(ps.ps_name)) - | Unsafe_string -> - if Config.safe_string then - error (Depend_on_unsafe_string_unit(ps.ps_name)); | Alerts _ -> () | Opaque -> register_import_as_opaque penv modname) ps.ps_flags; @@ -234,29 +236,33 @@ let acknowledge_pers_struct penv short_path_comps check modname pers_sig pm = register_pers_for_short_paths penv ps (short_path_comps ps.ps_name pm); ps -let read_pers_struct penv val_of_pers_sig short_path_comps check modname filename = +let read_pers_struct penv val_of_pers_sig short_path_comps check cmi = + let modname = Unit_info.Artifact.modname cmi in + let filename = Unit_info.Artifact.filename cmi in add_import penv modname; let cmi = Cmi_cache.read filename in - let pers_sig = { Persistent_signature.filename; cmi } in + let pers_sig = { Persistent_signature.filename; cmi; visibility = Visible } in let pm = val_of_pers_sig pers_sig in let ps = acknowledge_pers_struct penv short_path_comps check modname pers_sig pm in (ps, pm) -let find_pers_struct penv val_of_pers_sig short_path_comps check name = +let find_pers_struct ~allow_hidden penv val_of_pers_sig short_path_comps check name = let {persistent_structures; _} = penv in if name = "*predef*" then raise Not_found; match Hashtbl.find persistent_structures name with - | Found (ps, pm) -> (ps, pm) + | Found (ps, pm) when allow_hidden || ps.ps_visibility = Load_path.Visible -> + (ps, pm) + | Found _ -> raise Not_found | Missing -> raise Not_found | exception Not_found -> match can_load_cmis penv with | Cannot_load_cmis _ -> raise Not_found | Can_load_cmis -> let psig = - match !Persistent_signature.load ~unit_name:name with + match !Persistent_signature.load ~allow_hidden ~unit_name:name with | Some psig -> psig | None -> - Hashtbl.add persistent_structures name Missing; + if allow_hidden then Hashtbl.add persistent_structures name Missing; raise Not_found in add_import penv name; @@ -264,10 +270,11 @@ let find_pers_struct penv val_of_pers_sig short_path_comps check name = let ps = acknowledge_pers_struct penv short_path_comps check name psig pm in (ps, pm) +module Style = Misc.Style (* Emits a warning if there is no valid cmi for name *) -let check_pers_struct penv f1 f2 ~loc name = +let check_pers_struct ~allow_hidden penv f1 f2 ~loc name = try - ignore (find_pers_struct penv f1 f2 false name) + ignore (find_pers_struct ~allow_hidden penv f1 f2 false name) with | Not_found -> let warn = Warnings.No_cmi_file(name, None) in @@ -282,27 +289,26 @@ let check_pers_struct penv f1 f2 ~loc name = | Illegal_renaming(name, ps_name, filename) -> Format.asprintf " %a@ contains the compiled interface for @ \ - %s when %s was expected" - Location.print_filename filename ps_name name + %a when %a was expected" + (Style.as_inline_code Location.print_filename) filename + Style.inline_code ps_name + Style.inline_code name | Inconsistent_import _ -> assert false | Need_recursive_types name -> - Format.sprintf - "%s uses recursive types" - name - | Depend_on_unsafe_string_unit name -> - Printf.sprintf "%s uses -unsafe-string" - name + Format.asprintf + "%a uses recursive types" + Style.inline_code name in let warn = Warnings.No_cmi_file(name, Some msg) in Location.prerr_warning loc warn -let read penv f1 f2 modname filename = - snd (read_pers_struct penv f1 f2 true modname filename) +let read penv f1 f2 a = + snd (read_pers_struct penv f1 f2 true a) -let find penv f1 f2 name = - snd (find_pers_struct penv f1 f2 true name) +let find ~allow_hidden penv f1 f2 name = + snd (find_pers_struct ~allow_hidden penv f1 f2 true name) -let check penv f1 f2 ~loc name = +let check ~allow_hidden penv f1 f2 ~loc name = let {persistent_structures; _} = penv in if not (Hashtbl.mem persistent_structures name) then begin (* PR#6843: record the weak dependency ([add_import]) regardless of @@ -311,11 +317,11 @@ let check penv f1 f2 ~loc name = add_import penv name; if (Warnings.is_active (Warnings.No_cmi_file("", None))) then !add_delayed_check_forward - (fun () -> check_pers_struct penv f1 f2 ~loc name) + (fun () -> check_pers_struct ~allow_hidden penv f1 f2 ~loc name) end let crc_of_unit penv f1 f2 name = - let (ps, _pm) = find_pers_struct penv f1 f2 true name in + let (ps, _pm) = find_pers_struct ~allow_hidden:true penv f1 f2 true name in let crco = try List.assoc name ps.ps_crcs @@ -343,7 +349,6 @@ let make_cmi penv modname sign alerts = List.concat [ if !Clflags.recursive_types then [Cmi_format.Rectypes] else []; if !Clflags.opaque then [Cmi_format.Opaque] else []; - (if !Clflags.unsafe_string then [Cmi_format.Unsafe_string] else []); [Alerts alerts]; ] in @@ -356,7 +361,7 @@ let make_cmi penv modname sign alerts = } let save_cmi penv psig pm = - let { Persistent_signature.filename; cmi } = psig in + let { Persistent_signature.filename; cmi; visibility } = psig in Misc.try_finally (fun () -> let { cmi_name = modname; @@ -375,6 +380,7 @@ let save_cmi penv psig pm = ps_crcs = (cmi.cmi_name, Some crc) :: imports; ps_filename = filename; ps_flags = flags; + ps_visibility = visibility } in save_pers_struct penv crc ps pm ) @@ -385,21 +391,22 @@ let report_error ppf = function | Illegal_renaming(modname, ps_name, filename) -> fprintf ppf "Wrong file naming: %a@ contains the compiled interface for@ \ - %s when %s was expected" - Location.print_filename filename ps_name modname + %a when %a was expected" + (Style.as_inline_code Location.print_filename) filename + Style.inline_code ps_name + Style.inline_code modname | Inconsistent_import(name, source1, source2) -> fprintf ppf "@[The files %a@ and %a@ \ - make inconsistent assumptions@ over interface %s@]" - Location.print_filename source1 Location.print_filename source2 name + make inconsistent assumptions@ over interface %a@]" + (Style.as_inline_code Location.print_filename) source1 + (Style.as_inline_code Location.print_filename) source2 + Style.inline_code name | Need_recursive_types(import) -> fprintf ppf - "@[Invalid import of %s, which uses recursive types.@ %s@]" - import "The compilation flag -rectypes is required" - | Depend_on_unsafe_string_unit(import) -> - fprintf ppf - "@[Invalid import of %s, compiled with -unsafe-string.@ %s@]" - import "This compiler has been configured in strict \ - safe-string mode (-force-safe-string)" + "@[Invalid import of %a, which uses recursive types.@ \ + The compilation flag %a is required@]" + Style.inline_code import + Style.inline_code "-rectypes" let () = Location.register_error_of_exn diff --git a/src/ocaml/typing/persistent_env.mli b/src/ocaml/typing/persistent_env.mli index 60506f4b6a..1acb5b3d65 100644 --- a/src/ocaml/typing/persistent_env.mli +++ b/src/ocaml/typing/persistent_env.mli @@ -24,7 +24,6 @@ type error = | Illegal_renaming of modname * modname * filepath | Inconsistent_import of modname * filepath * filepath | Need_recursive_types of modname - | Depend_on_unsafe_string_unit of modname exception Error of error @@ -33,12 +32,14 @@ val report_error: Format.formatter -> error -> unit module Persistent_signature : sig type t = { filename : string; (** Name of the file containing the signature. *) - cmi : Cmi_format.cmi_infos } + cmi : Cmi_format.cmi_infos; + visibility : Load_path.visibility + } (** Function used to load a persistent signature. The default is to look for the .cmi file in the load path. This function can be overridden to load it from memory, for instance to build a self-contained toplevel. *) - val load : (unit_name:string -> t option) ref + val load : (allow_hidden:bool -> unit_name:string -> t option) ref end type can_load_cmis = @@ -58,14 +59,14 @@ val fold : 'a t -> (modname -> 'a -> 'b -> 'b) -> 'b -> 'b val read : 'a t -> (Persistent_signature.t -> 'a) -> (string -> 'a -> Short_paths.Desc.Module.components Lazy.t) - -> modname -> filepath -> 'a -val find : 'a t -> (Persistent_signature.t -> 'a) + -> Unit_info.Artifact.t -> 'a +val find : allow_hidden:bool -> 'a t -> (Persistent_signature.t -> 'a) -> (string -> 'a -> Short_paths.Desc.Module.components Lazy.t) -> modname -> 'a val find_in_cache : 'a t -> modname -> 'a option -val check : 'a t -> (Persistent_signature.t -> 'a) +val check : allow_hidden:bool -> 'a t -> (Persistent_signature.t -> 'a) -> (string -> 'a -> Short_paths.Desc.Module.components Lazy.t) -> loc:Location.t -> modname -> unit diff --git a/src/ocaml/typing/predef.ml b/src/ocaml/typing/predef.ml index 6d28f25f1f..7344be15fc 100644 --- a/src/ocaml/typing/predef.ml +++ b/src/ocaml/typing/predef.ml @@ -134,8 +134,8 @@ and ident_cons = ident_create "::" and ident_none = ident_create "None" and ident_some = ident_create "Some" -let mk_add_type add_type type_ident - ?manifest ?(immediate=Type_immediacy.Unknown) ?(kind=Type_abstract) env = +let mk_add_type add_type type_ident ?manifest + ?(immediate=Type_immediacy.Unknown) ?(kind=Type_abstract Definition) env = let decl = {type_params = []; type_arity = 0; @@ -155,10 +155,10 @@ let mk_add_type add_type type_ident in add_type type_ident decl env -let common_initial_env add_type add_extension empty_env = +let build_initial_env add_type add_extension empty_env = let add_type = mk_add_type add_type and add_type1 type_ident - ~variance ~separability ?(kind=fun _ -> Type_abstract) env = + ~variance ~separability ?(kind=fun _ -> Type_abstract Definition) env = let param = newgenvar () in let decl = {type_params = [param]; @@ -225,6 +225,7 @@ let common_initial_env add_type add_extension empty_env = ~kind:(fun tvar -> variant [cstr ident_none []; cstr ident_some [tvar]]) |> add_type ident_string + |> add_type ident_bytes |> add_type ident_unit ~immediate:Always ~kind:(variant [cstr ident_void []]) @@ -245,13 +246,6 @@ let common_initial_env add_type add_extension empty_env = |> add_extension ident_undefined_recursive_module [newgenty (Ttuple[type_string; type_int; type_int])] -let build_initial_env add_type add_exception empty_env = - let common = common_initial_env add_type add_exception empty_env in - let add_type = mk_add_type add_type in - let safe_string = add_type ident_bytes common in - let unsafe_string = add_type ident_bytes ~manifest:type_string common in - (safe_string, unsafe_string) - let builtin_values = List.map (fun id -> (Ident.name id, id)) all_predef_exns diff --git a/src/ocaml/typing/predef.mli b/src/ocaml/typing/predef.mli index 1edbb63ef9..ff67206f62 100644 --- a/src/ocaml/typing/predef.mli +++ b/src/ocaml/typing/predef.mli @@ -74,7 +74,7 @@ val ident_some : Ident.t val build_initial_env: (Ident.t -> type_declaration -> 'a -> 'a) -> (Ident.t -> extension_constructor -> 'a -> 'a) -> - 'a -> 'a * 'a + 'a -> 'a (* To initialize linker tables *) diff --git a/src/ocaml/typing/primitive.ml b/src/ocaml/typing/primitive.ml index bf4fe83248..f8e964cce1 100644 --- a/src/ocaml/typing/primitive.ml +++ b/src/ocaml/typing/primitive.ml @@ -24,7 +24,7 @@ type native_repr = | Same_as_ocaml_repr | Unboxed_float | Unboxed_integer of boxed_integer - | Untagged_int + | Untagged_immediate type description = { prim_name: string; (* Name of primitive or C function *) @@ -45,16 +45,16 @@ let is_ocaml_repr = function | Same_as_ocaml_repr -> true | Unboxed_float | Unboxed_integer _ - | Untagged_int -> false + | Untagged_immediate -> false let is_unboxed = function | Same_as_ocaml_repr - | Untagged_int -> false + | Untagged_immediate -> false | Unboxed_float | Unboxed_integer _ -> true let is_untagged = function - | Untagged_int -> true + | Untagged_immediate -> true | Same_as_ocaml_repr | Unboxed_float | Unboxed_integer _ -> false @@ -95,8 +95,7 @@ let parse_declaration valdecl ~native_repr_args ~native_repr_res = fatal_error "Primitive.parse_declaration" in let noalloc_attribute = - Attr_helper.has_no_payload_attribute ["noalloc"; "ocaml.noalloc"] - valdecl.pval_attributes + Attr_helper.has_no_payload_attribute "noalloc" valdecl.pval_attributes in if old_style_float && not (List.for_all is_ocaml_repr native_repr_args && @@ -181,7 +180,7 @@ let print p osig_val_decl = | Same_as_ocaml_repr -> None | Unboxed_float | Unboxed_integer _ -> if all_unboxed then None else Some oattr_unboxed - | Untagged_int -> if all_untagged then None else Some oattr_untagged + | Untagged_immediate -> if all_untagged then None else Some oattr_untagged in let type_attrs = List.map attr_of_native_repr p.prim_native_repr_args @ @@ -213,33 +212,40 @@ let equal_native_repr nr1 nr2 = match nr1, nr2 with | Same_as_ocaml_repr, Same_as_ocaml_repr -> true | Same_as_ocaml_repr, - (Unboxed_float | Unboxed_integer _ | Untagged_int) -> false + (Unboxed_float | Unboxed_integer _ | Untagged_immediate) -> false | Unboxed_float, Unboxed_float -> true | Unboxed_float, - (Same_as_ocaml_repr | Unboxed_integer _ | Untagged_int) -> false + (Same_as_ocaml_repr | Unboxed_integer _ | Untagged_immediate) -> false | Unboxed_integer bi1, Unboxed_integer bi2 -> equal_boxed_integer bi1 bi2 | Unboxed_integer _, - (Same_as_ocaml_repr | Unboxed_float | Untagged_int) -> false - | Untagged_int, Untagged_int -> true - | Untagged_int, + (Same_as_ocaml_repr | Unboxed_float | Untagged_immediate) -> false + | Untagged_immediate, Untagged_immediate -> true + | Untagged_immediate, (Same_as_ocaml_repr | Unboxed_float | Unboxed_integer _) -> false let native_name_is_external p = let nat_name = native_name p in nat_name <> "" && nat_name.[0] <> '%' +module Style = Misc.Style + let report_error ppf err = match err with | Old_style_float_with_native_repr_attribute -> - Format.fprintf ppf "Cannot use \"float\" in conjunction with \ - [%@unboxed]/[%@untagged]." + Format.fprintf ppf "Cannot use %a in conjunction with %a/%a." + Style.inline_code "float" + Style.inline_code "[@unboxed]" + Style.inline_code "[@untagged]" | Old_style_noalloc_with_noalloc_attribute -> - Format.fprintf ppf "Cannot use \"noalloc\" in conjunction with \ - [%@%@noalloc]." + Format.fprintf ppf "Cannot use %a in conjunction with %a." + Style.inline_code "noalloc" + Style.inline_code "[@@noalloc]" | No_native_primitive_with_repr_attribute -> Format.fprintf ppf - "[@The native code version of the primitive is mandatory@ \ - when attributes [%@untagged] or [%@unboxed] are present.@]" + "@[The native code version of the primitive is mandatory@ \ + when attributes %a or %a are present.@]" + Style.inline_code "[@untagged]" + Style.inline_code "[@unboxed]" let () = Location.register_error_of_exn diff --git a/src/ocaml/typing/primitive.mli b/src/ocaml/typing/primitive.mli index e8376ad552..3d3ae8854c 100644 --- a/src/ocaml/typing/primitive.mli +++ b/src/ocaml/typing/primitive.mli @@ -23,7 +23,7 @@ type native_repr = | Same_as_ocaml_repr | Unboxed_float | Unboxed_integer of boxed_integer - | Untagged_int + | Untagged_immediate type description = private { prim_name: string; (* Name of primitive or C function *) diff --git a/src/ocaml/typing/printpat.ml b/src/ocaml/typing/printpat.ml index 64094b63ec..bc3578ce41 100644 --- a/src/ocaml/typing/printpat.ml +++ b/src/ocaml/typing/printpat.ml @@ -52,7 +52,7 @@ let rec pretty_val : type k . _ -> k general_pattern -> _ = fun ppf v -> | [] -> match v.pat_desc with | Tpat_any -> fprintf ppf "_" - | Tpat_var (x,_) -> fprintf ppf "%s" (Ident.name x) + | Tpat_var (x,_,_) -> fprintf ppf "%s" (Ident.name x) | Tpat_constant c -> fprintf ppf "%s" (pretty_const c) | Tpat_tuple vs -> fprintf ppf "@[(%a)@]" (pretty_vals ",") vs @@ -84,7 +84,7 @@ let rec pretty_val : type k . _ -> k general_pattern -> _ = fun ppf v -> | (_,_,{pat_desc=Tpat_any}) -> false (* do not show lbl=_ *) | _ -> true) lvs in begin match filtered_lvs with - | [] -> fprintf ppf "_" + | [] -> fprintf ppf "{ _ }" | (_, lbl, _) :: q -> let elision_mark ppf = (* we assume that there is no label repetitions here *) @@ -98,7 +98,7 @@ let rec pretty_val : type k . _ -> k general_pattern -> _ = fun ppf v -> fprintf ppf "@[[| %a |]@]" (pretty_vals " ;") vs | Tpat_lazy v -> fprintf ppf "@[<2>lazy@ %a@]" pretty_arg v - | Tpat_alias (v, x,_) -> + | Tpat_alias (v, x,_,_) -> fprintf ppf "@[(%a@ as %a)@]" pretty_val v Ident.print x | Tpat_value v -> fprintf ppf "%a" pretty_val (v :> pattern) @@ -144,26 +144,20 @@ and pretty_lvals ppf = function fprintf ppf "%s=%a;@ %a" lbl.lbl_name pretty_val v pretty_lvals rest -let top_pretty ppf v = - fprintf ppf "@[%a@]@?" pretty_val v - -let pretty_pat p = - top_pretty Format.str_formatter p ; - prerr_string (Format.flush_str_formatter ()) +let pretty_pat ppf p = + fprintf ppf "@[%a@]" pretty_val p type 'k matrix = 'k general_pattern list list -let pretty_line fmt = +let pretty_line ppf line = + Format.fprintf ppf "@["; List.iter (fun p -> - Format.fprintf fmt " <"; - top_pretty fmt p; - Format.fprintf fmt ">"; - ) - -let pretty_matrix fmt (pss : 'k matrix) = - Format.fprintf fmt "begin matrix\n" ; - List.iter (fun ps -> - pretty_line fmt ps ; - Format.fprintf fmt "\n" - ) pss; - Format.fprintf fmt "end matrix\n%!" + Format.fprintf ppf "<%a>@ " + pretty_val p + ) line; + Format.fprintf ppf "@]" + +let pretty_matrix ppf (pss : 'k matrix) = + Format.fprintf ppf "@[ %a@]" + (Format.pp_print_list ~pp_sep:Format.pp_print_cut pretty_line) + pss diff --git a/src/ocaml/typing/printpat.mli b/src/ocaml/typing/printpat.mli index 1865a2ab29..1f03508c2d 100644 --- a/src/ocaml/typing/printpat.mli +++ b/src/ocaml/typing/printpat.mli @@ -16,11 +16,11 @@ val pretty_const - : Asttypes.constant -> string -val top_pretty - : Format.formatter -> 'k Typedtree.general_pattern -> unit + : Asttypes.constant -> string +val pretty_val : Format.formatter -> 'k Typedtree.general_pattern -> unit + val pretty_pat - : 'k Typedtree.general_pattern -> unit + : Format.formatter -> 'k Typedtree.general_pattern -> unit val pretty_line : Format.formatter -> 'k Typedtree.general_pattern list -> unit val pretty_matrix diff --git a/src/ocaml/typing/printtyp.ml b/src/ocaml/typing/printtyp.ml index 450450870a..833db2360a 100644 --- a/src/ocaml/typing/printtyp.ml +++ b/src/ocaml/typing/printtyp.ml @@ -28,12 +28,11 @@ open Types open Btype open Outcometree -(* Print a long identifier *) +module Sig_component_kind = Shape.Sig_component_kind +module Style = Misc.Style -let rec longident ppf = function - | Lident s -> pp_print_string ppf s - | Ldot(p, s) -> fprintf ppf "%a.%s" longident p s - | Lapply(p1, p2) -> fprintf ppf "%a(%a)" longident p1 longident p2 +(* Print a long identifier *) +let longident = Pprintast.longident let () = Env.print_longident := longident @@ -42,7 +41,6 @@ let () = Env.print_longident := longident module Out_name = struct let create x = { printed_name = x } let print x = x.printed_name - let set out_name x = out_name.printed_name <- x end (** Some identifiers may require hiding when printing *) @@ -56,15 +54,17 @@ let printing_env = ref Env.empty cmi present on the file system *) let in_printing_env f = Env.without_cmis f !printing_env -let human_unique n id = Printf.sprintf "%s/%d" (Ident.name id) n + type namespace = Shape.Sig_component_kind.t = + | Value + | Type + | Constructor + | Label + | Module + | Module_type + | Extension_constructor + | Class + | Class_type -type namespace = - | Type - | Module - | Module_type - | Class - | Class_type - | Other (** Other bypasses the unique name identifier mechanism *) module Namespace = struct @@ -74,49 +74,46 @@ module Namespace = struct | Module_type -> 2 | Class -> 3 | Class_type -> 4 - | Other -> 5 + | Extension_constructor | Value | Constructor | Label -> 5 + (* we do not handle those component *) - let size = 1 + id Other + let size = 1 + id Value - let show = - function - | Type -> "type" - | Module -> "module" - | Module_type -> "module type" - | Class -> "class" - | Class_type -> "class type" - | Other -> "" - let pp ppf x = Format.pp_print_string ppf (show x) + let pp ppf x = + Format.pp_print_string ppf (Shape.Sig_component_kind.to_string x) let lookup = let to_lookup f lid = fst @@ in_printing_env (f (Lident lid)) in function - | Type -> to_lookup Env.find_type_by_name - | Module -> to_lookup Env.find_module_by_name - | Module_type -> to_lookup Env.find_modtype_by_name - | Class -> to_lookup Env.find_class_by_name - | Class_type -> to_lookup Env.find_cltype_by_name - | Other -> fun _ -> raise Not_found + | Some Type -> to_lookup Env.find_type_by_name + | Some Module -> to_lookup Env.find_module_by_name + | Some Module_type -> to_lookup Env.find_modtype_by_name + | Some Class -> to_lookup Env.find_class_by_name + | Some Class_type -> to_lookup Env.find_cltype_by_name + | None | Some(Value|Extension_constructor|Constructor|Label) -> + fun _ -> raise Not_found let location namespace id = let path = Path.Pident id in try Some ( match namespace with - | Type -> (in_printing_env @@ Env.find_type path).type_loc - | Module -> (in_printing_env @@ Env.find_module path).md_loc - | Module_type -> (in_printing_env @@ Env.find_modtype path).mtd_loc - | Class -> (in_printing_env @@ Env.find_class path).cty_loc - | Class_type -> (in_printing_env @@ Env.find_cltype path).clty_loc - | Other -> Location.none + | Some Type -> (in_printing_env @@ Env.find_type path).type_loc + | Some Module -> (in_printing_env @@ Env.find_module path).md_loc + | Some Module_type -> (in_printing_env @@ Env.find_modtype path).mtd_loc + | Some Class -> (in_printing_env @@ Env.find_class path).cty_loc + | Some Class_type -> (in_printing_env @@ Env.find_cltype path).clty_loc + | Some (Extension_constructor|Value|Constructor|Label) | None -> + Location.none ) with Not_found -> None let best_class_namespace = function - | Papply _ | Pdot _ -> Module + | Papply _ | Pdot _ -> Some Module + | Pextra_ty _ -> assert false (* Only in type path *) | Pident c -> - match location Class c with - | Some _ -> Class - | None -> Class_type + match location (Some Class) c with + | Some _ -> Some Class + | None -> Some Class_type end @@ -130,19 +127,37 @@ module Conflicts = struct type explanation = { kind: namespace; name:string; root_name:string; location:Location.t} let explanations = ref M.empty - let collect_explanation namespace n id = - let name = human_unique n id in + + let add namespace name id = + match Namespace.location (Some namespace) id with + | None -> () + | Some location -> + let explanation = + { kind = namespace; location; name; root_name=Ident.name id} + in + explanations := M.add name explanation !explanations + + let collect_explanation namespace id ~name = let root_name = Ident.name id in - if not (M.mem name !explanations) then - match Namespace.location namespace id with - | None -> () - | Some location -> - let explanation = { kind = namespace; location; name; root_name } in - explanations := M.add name explanation !explanations + (* if [name] is of the form "root_name/%d", we register both + [id] and the identifier in scope for [root_name]. + *) + if root_name <> name && not (M.mem name !explanations) then + begin + add namespace name id; + if not (M.mem root_name !explanations) then + (* lookup the identifier in scope with name [root_name] and + add it too + *) + match Namespace.lookup (Some namespace) root_name with + | Pident root_id -> add namespace root_name root_id + | exception Not_found | _ -> () + end let pp_explanation ppf r= - Format.fprintf ppf "@[%a:@,Definition of %s %s@]" - Location.print_loc r.location (Namespace.show r.kind) r.name + Format.fprintf ppf "@[%a:@,Definition of %s %a@]" + Location.print_loc r.location (Sig_component_kind.to_string r.kind) + Style.inline_code r.name let print_located_explanations ppf l = Format.fprintf ppf "@[%a@]" (Format.pp_print_list pp_explanation) l @@ -169,20 +184,22 @@ module Conflicts = struct | [namespace, a] -> Format.fprintf ppf "@ \ - @[<2>Hint: The %a %s has been defined multiple times@ \ + @[<2>@{Hint@}: The %a %a has been defined multiple times@ \ in@ this@ toplevel@ session.@ \ Some toplevel values still refer to@ old@ versions@ of@ this@ %a.\ @ Did you try to redefine them?@]" - Namespace.pp namespace a Namespace.pp namespace + Namespace.pp namespace + Style.inline_code a Namespace.pp namespace | (namespace, _) :: _ :: _ -> Format.fprintf ppf "@ \ - @[<2>Hint: The %a %a have been defined multiple times@ \ + @[<2>@{Hint@}: The %a %a have been defined multiple times@ \ in@ this@ toplevel@ session.@ \ Some toplevel values still refer to@ old@ versions@ of@ those@ %a.\ @ Did you try to redefine them?@]" pp_namespace_plural namespace - Format.(pp_print_list ~pp_sep:conj pp_print_string) (List.map snd names) + Format.(pp_print_list ~pp_sep:conj Style.inline_code) + (List.map snd names) pp_namespace_plural namespace in Array.iter (pp_submsg ppf) submsgs @@ -209,43 +226,30 @@ module Naming_context = struct let enabled = ref true let enable b = enabled := b -(** Name mapping *) -type mapping = - | Need_unique_name of int Ident.Map.t - (** The same name has already been attributed to multiple types. - The [map] argument contains the specific binding time attributed to each - types. - *) - | Uniquely_associated_to of Ident.t * out_name - (** For now, the name [Ident.name id] has been attributed to [id], - [out_name] is used to expand this name if a conflict arises - at a later point - *) - | Associated_to_pervasives of out_name - (** [Associated_to_pervasives out_name] is used when the item - [Stdlib.$name] has been associated to the name [$name]. - Upon a conflict, this name will be expanded to ["Stdlib." ^ name ] *) - -let hid_start = 0 - -let add_hid_id id map = - let new_id = 1 + Ident.Map.fold (fun _ -> Int.max) map hid_start in - new_id, Ident.Map.add id new_id map - -let find_hid id map = - try Ident.Map.find id map, map with - Not_found -> add_hid_id id map - -let pervasives name = "Stdlib." ^ name - -let map = Array.make Namespace.size M.empty -let get namespace = map.(Namespace.id namespace) -let set namespace x = map.(Namespace.id namespace) <- x - -(* Names used in recursive definitions are not considered when determining - if a name is already attributed in the current environment. - This is a complementary version of hidden_rec_items used by short-path. *) -let protected = ref S.empty +(* Names bound in recursive definitions should be considered as bound + in the environment when printing identifiers but not when trying + to find shortest path. + For instance, if we define + [{ + module Avoid__me = struct + type t = A + end + type t = X + type u = [` A of t * t ] + module M = struct + type t = A of [ u | `B ] + type r = Avoid__me.t + end + }] + It is is important that in the definition of [t] that the outer type [t] is + printed as [t/2] reserving the name [t] to the type being defined in the + current recursive definition. + Contrarily, in the definition of [r], one should not shorten the + path [Avoid__me.t] to [r] until the end of the definition of [r]. + The [bound_in_recursion] bridges the gap between those two slightly different + notions of printing environment. +*) +let bound_in_recursion = ref M.empty (* When dealing with functor arguments, identity becomes fuzzy because the same syntactic argument may be represented by different identifiers during the @@ -257,96 +261,86 @@ let with_arg id f = let fuzzy_id namespace id = namespace = Module && S.mem (Ident.name id) !fuzzy let with_hidden ids f = - let update m id = S.add (Ident.name id.ident) m in - protect_refs [ R(protected, List.fold_left update !protected ids)] f - -let pervasives_name namespace name = - if not !enabled then Out_name.create name else - match M.find name (get namespace) with - | Associated_to_pervasives r -> r - | Need_unique_name _ -> Out_name.create (pervasives name) - | Uniquely_associated_to (id',r) -> - let hid, map = add_hid_id id' Ident.Map.empty in - Out_name.set r (human_unique hid id'); - Conflicts.collect_explanation namespace hid id'; - set namespace @@ M.add name (Need_unique_name map) (get namespace); - Out_name.create (pervasives name) - | exception Not_found -> - let r = Out_name.create name in - set namespace @@ M.add name (Associated_to_pervasives r) (get namespace); - r - -(** Lookup for preexisting named item within the current {!printing_env} *) -let env_ident namespace name = - if S.mem name !protected then None else - match Namespace.lookup namespace name with - | Pident id -> Some id - | _ -> None - | exception Not_found -> None - -(** Associate a name to the identifier [id] within [namespace] *) -let ident_name_simple namespace id = - if not !enabled || fuzzy_id namespace id then - Out_name.create (Ident.name id) + let update m id = M.add (Ident.name id.ident) id.ident m in + let updated = List.fold_left update !bound_in_recursion ids in + protect_refs [ R(bound_in_recursion, updated )] f + +let human_id id index = + (* The identifier with index [k] is the (k+1)-th most recent identifier in + the printing environment. We print them as [name/(k+1)] except for [k=0] + which is printed as [name] rather than [name/1]. + *) + if index = 0 then + Ident.name id else - let name = Ident.name id in - match M.find name (get namespace) with - | Uniquely_associated_to (id',r) when Ident.same id id' -> - r - | Need_unique_name map -> - let hid, m = find_hid id map in - Conflicts.collect_explanation namespace hid id; - set namespace @@ M.add name (Need_unique_name m) (get namespace); - Out_name.create (human_unique hid id) - | Uniquely_associated_to (id',r) -> - let hid', m = find_hid id' Ident.Map.empty in - let hid, m = find_hid id m in - Out_name.set r (human_unique hid' id'); - List.iter (fun (id,hid) -> Conflicts.collect_explanation namespace hid id) - [id, hid; id', hid' ]; - set namespace @@ M.add name (Need_unique_name m) (get namespace); - Out_name.create (human_unique hid id) - | Associated_to_pervasives r -> - Out_name.set r ("Stdlib." ^ Out_name.print r); - let hid, m = find_hid id Ident.Map.empty in - set namespace @@ M.add name (Need_unique_name m) (get namespace); - Out_name.create (human_unique hid id) - | exception Not_found -> - let r = Out_name.create name in - set namespace - @@ M.add name (Uniquely_associated_to (id,r) ) (get namespace); - r - -(** Same as {!ident_name_simple} but lookup to existing named identifiers - in the current {!printing_env} *) -let ident_name namespace id = - begin match env_ident namespace (Ident.name id) with - | Some id' -> ignore (ident_name_simple namespace id') - | None -> () - end; - ident_name_simple namespace id - -let reset () = - Array.iteri ( fun i _ -> map.(i) <- M.empty ) map - -let with_ctx f = - let old = Array.copy map in - try_finally f - ~always:(fun () -> Array.blit old 0 map 0 (Array.length map)) + let ordinal = index + 1 in + String.concat "/" [Ident.name id; string_of_int ordinal] + +let indexed_name namespace id = + let find namespace id env = match namespace with + | Type -> Env.find_type_index id env + | Module -> Env.find_module_index id env + | Module_type -> Env.find_modtype_index id env + | Class -> Env.find_class_index id env + | Class_type-> Env.find_cltype_index id env + | Value | Extension_constructor | Constructor | Label -> None + in + let index = + match M.find_opt (Ident.name id) !bound_in_recursion with + | Some rec_bound_id -> + (* the identifier name appears in the current group of recursive + definition *) + if Ident.same rec_bound_id id then + Some 0 + else + (* the current recursive definition shadows one more time the + previously existing identifier with the same name *) + Option.map succ (in_printing_env (find namespace id)) + | None -> + in_printing_env (find namespace id) + in + let index = + (* If [index] is [None] at this point, it might indicate that + the identifier id is not defined in the environment, while there + are other identifiers in scope that share the same name. + Currently, this kind of partially incoherent environment happens + within functor error messages where the left and right hand side + have a different views of the environment at the source level. + Printing the source-level by using a default index of `0` + seems like a reasonable compromise in this situation however.*) + Option.value index ~default:0 + in + human_id id index +let ident_name namespace id = + match namespace, !enabled with + | None, _ | _, false -> Out_name.create (Ident.name id) + | Some namespace, true -> + if fuzzy_id namespace id then Out_name.create (Ident.name id) + else + let name = indexed_name namespace id in + Conflicts.collect_explanation namespace id ~name; + Out_name.create name end let ident_name = Naming_context.ident_name -let reset_naming_context = Naming_context.reset let ident ppf id = pp_print_string ppf - (Out_name.print (Naming_context.ident_name_simple Other id)) + (Out_name.print (Naming_context.ident_name None id)) + +let namespaced_ident namespace id = + Out_name.print (Naming_context.ident_name (Some namespace) id) + (* Print a path *) let ident_stdlib = Ident.create_persistent "Stdlib" -let non_shadowed_pervasive = function - | Pdot(Pident id, _) -> Ident.same id ident_stdlib +let non_shadowed_stdlib namespace = function + | Pdot(Pident id, s) as path -> + Ident.same id ident_stdlib && + (match Namespace.lookup namespace s with + | path' -> Path.same path path' + | exception Not_found -> true) | _ -> false let find_double_underscore s = @@ -378,6 +372,8 @@ let rec rewrite_double_underscore_paths env p = | Papply (a, b) -> Papply (rewrite_double_underscore_paths env a, rewrite_double_underscore_paths env b) + | Pextra_ty (p, extra) -> + Pextra_ty (rewrite_double_underscore_paths env p, extra) | Pident id -> let name = Ident.name id in match find_double_underscore name with @@ -386,7 +382,7 @@ let rec rewrite_double_underscore_paths env p = let better_lid = Ldot (Lident (String.sub name 0 i), - String.capitalize_ascii + Unit_info.modulize (String.sub name (i + 2) (String.length name - i - 2))) in match Env.find_module_by_name better_lid env with @@ -403,31 +399,41 @@ let rewrite_double_underscore_paths env p = else rewrite_double_underscore_paths env p -let rec tree_of_path namespace = function +let rec tree_of_path ?(disambiguation=true) namespace p = + let tree_of_path namespace p = tree_of_path ~disambiguation namespace p in + let namespace = if disambiguation then namespace else None in + match p with | Pident id -> Oide_ident (ident_name namespace id) - | Pdot(_, s) as path when non_shadowed_pervasive path -> - Oide_ident (Naming_context.pervasives_name namespace s) - | Pdot(Pident t, s) - when namespace=Type && not (Path.is_uident (Ident.name t)) -> - (* [t.A]: inline record of the constructor [A] from type [t] *) - Oide_dot (Oide_ident (ident_name Type t), s) + | Pdot(_, s) as path when non_shadowed_stdlib namespace path -> + Oide_ident (Out_name.create s) | Pdot(p, s) -> - Oide_dot (tree_of_path Module p, s) + Oide_dot (tree_of_path (Some Module) p, s) | Papply(p1, p2) -> - Oide_apply (tree_of_path Module p1, tree_of_path Module p2) + let t1 = tree_of_path (Some Module) p1 in + let t2 = tree_of_path (Some Module) p2 in + Oide_apply (t1, t2) + | Pextra_ty (p, extra) -> begin + (* inline record types are syntactically prevented from escaping their + binding scope, and are never shown to users. *) + match extra with + Pcstr_ty s -> + Oide_dot (tree_of_path (Some Type) p, s) + | Pext_ty -> + tree_of_path None p + end -let tree_of_path namespace p = - tree_of_path namespace (rewrite_double_underscore_paths !printing_env p) +let tree_of_path ?disambiguation namespace p = + tree_of_path ?disambiguation namespace + (rewrite_double_underscore_paths !printing_env p) let path ppf p = - !Oprint.out_ident ppf (tree_of_path Other p) + !Oprint.out_ident ppf (tree_of_path None p) let string_of_path p = Format.asprintf "%a" path p let strings_of_paths namespace p = - reset_naming_context (); let trees = List.map (tree_of_path namespace) p in List.map (Format.asprintf "%a" !Oprint.out_ident) trees @@ -486,6 +492,10 @@ let rec raw_type ppf ty = ty.scope raw_type_desc ty.desc end and raw_type_list tl = raw_list raw_type tl +and raw_lid_type_list tl = + raw_list (fun ppf (lid, typ) -> + fprintf ppf "(@,%a,@,%a)" longident lid raw_type typ) + tl and raw_type_desc ppf = function Tvar name -> fprintf ppf "Tvar %a" print_name name | Tarrow(l,t1,t2,c) -> @@ -535,8 +545,8 @@ and raw_type_desc ppf = function | Some(p,tl) -> fprintf ppf "Some(@,%a,@,%a)" path p raw_type_list tl) | Tpackage (p, fl) -> - fprintf ppf "@[Tpackage(@,%a@,%a)@]" path p - raw_type_list (List.map snd fl) + fprintf ppf "@[Tpackage(@,%a,@,%a)@]" path p raw_lid_type_list fl + and raw_row_fixed ppf = function | None -> fprintf ppf "None" | Some Types.Fixed_private -> fprintf ppf "Some Fixed_private" @@ -576,7 +586,6 @@ let set_printing_env env = let wrap_printing_env env f = set_printing_env (Env.update_short_paths env); - reset_naming_context (); try_finally f ~always:(fun () -> set_printing_env Env.empty) let wrap_printing_env ?error:_ env f = @@ -637,6 +646,13 @@ let best_class_type_path_simple p = then p else Short_paths.find_class_type_simple (Env.short_paths !printing_env) p +(* When building a tree for a best type path, we should not disambiguate + identifiers whenever the short-path algorithm detected a better path than + the original one.*) +let tree_of_best_type_path p p' = + if Path.same p p' then tree_of_path (Some Type) p' + else tree_of_path ~disambiguation:false None p' + (* Print a type expression *) let proxy ty = Transient_expr.repr (proxy ty) @@ -700,6 +716,70 @@ let printer_iter_type_expr f ty = | _ -> Btype.iter_type_expr f ty +module Internal_names : sig + + val reset : unit -> unit + + val add : Path.t -> unit + + val print_explanations : Env.t -> Format.formatter -> unit + +end = struct + + let names = ref Ident.Set.empty + + let reset () = + names := Ident.Set.empty + + let add p = + match p with + | Pident id -> + let name = Ident.name id in + if String.length name > 0 && name.[0] = '$' then begin + names := Ident.Set.add id !names + end + | Pdot _ | Papply _ | Pextra_ty _ -> () + + let print_explanations env ppf = + let constrs = + Ident.Set.fold + (fun id acc -> + let p = Pident id in + match Env.find_type p env with + | exception Not_found -> acc + | decl -> + match type_origin decl with + | Existential constr -> + let prev = String.Map.find_opt constr acc in + let prev = Option.value ~default:[] prev in + String.Map.add constr (tree_of_path None p :: prev) acc + | Definition | Rec_check_regularity -> acc) + !names String.Map.empty + in + String.Map.iter + (fun constr out_idents -> + match out_idents with + | [] -> () + | [out_ident] -> + fprintf ppf + "@ @[<2>@{Hint@}:@ %a@ is an existential type@ \ + bound by the constructor@ %a.@]" + (Style.as_inline_code !Oprint.out_ident) out_ident + Style.inline_code constr + | out_ident :: out_idents -> + fprintf ppf + "@ @[<2>@{Hint@}:@ %a@ and %a@ are existential types@ \ + bound by the constructor@ %a.@]" + (Format.pp_print_list + ~pp_sep:(fun ppf () -> fprintf ppf ",@ ") + (Style.as_inline_code !Oprint.out_ident)) + (List.rev out_idents) + (Style.as_inline_code !Oprint.out_ident) out_ident + Style.inline_code constr) + constrs + +end + module Names : sig val reset_names : unit -> unit @@ -707,10 +787,10 @@ module Names : sig val add_subst : (type_expr * type_expr) list -> unit val new_name : unit -> string - val new_weak_name : type_expr -> unit -> string + val new_var_name : non_gen:bool -> type_expr -> unit -> string val name_of_type : (unit -> string) -> transient_expr -> string - val check_name_of_type : transient_expr -> unit + val check_name_of_type : non_gen:bool -> transient_expr -> unit val remove_names : transient_expr list -> unit @@ -777,11 +857,7 @@ end = struct || String.Set.mem name !named_weak_vars let rec new_name () = - let name = - if !name_counter < 26 - then String.make 1 (Char.chr(97 + !name_counter)) - else String.make 1 (Char.chr(97 + !name_counter mod 26)) ^ - Int.to_string(!name_counter / 26) in + let name = Misc.letter_of_int !name_counter in incr name_counter; if name_is_already_used name then new_name () else name @@ -795,6 +871,10 @@ end = struct name end + let new_var_name ~non_gen ty () = + if non_gen then new_weak_name ty () + else new_name () + let name_of_type name_generator t = (* We've already been through repr at this stage, so t is our representative of the union-find class. *) @@ -807,16 +887,16 @@ end = struct (* Some part of the type we've already printed has assigned another * unification variable to that name. We want to keep the name, so * try adding a number until we find a name that's not taken. *) - let current_name = ref name in - let i = ref 0 in - while List.exists - (fun (_, name') -> !current_name = name') - !names - do - current_name := name ^ (Int.to_string !i); - i := !i + 1; - done; - !current_name + let available name = + List.for_all + (fun (_, name') -> name <> name') + !names + in + if available name then name + else + let suffixed i = name ^ Int.to_string i in + let i = Misc.find_first_mono (fun i -> available (suffixed i)) in + suffixed i | _ -> (* No name available, create a new one *) name_generator () @@ -825,7 +905,9 @@ end = struct if name <> "_" then names := (t, name) :: !names; name - let check_name_of_type t = ignore(name_of_type new_name t) + let check_name_of_type ~non_gen px = + let name_gen = new_var_name ~non_gen (Transient_expr.type_expr px) in + ignore(name_of_type name_gen px) let remove_names tyl = let tyl = List.map substitute tyl in @@ -880,8 +962,8 @@ let add_alias_proxy px = let add_alias ty = add_alias_proxy (proxy ty) -let add_printed_alias_proxy px = - Names.check_name_of_type px; +let add_printed_alias_proxy ~non_gen px = + Names.check_name_of_type ~non_gen px; printed_aliases := px :: !printed_aliases let add_printed_alias ty = add_printed_alias_proxy (proxy ty) @@ -1000,10 +1082,10 @@ let reset_loop_marks () = visited_objects := []; aliased := []; delayed := []; printed_aliases := [] let reset_except_context () = - Names.reset_names (); reset_loop_marks () + Names.reset_names (); reset_loop_marks (); Internal_names.reset () let reset () = - reset_naming_context (); Conflicts.reset (); + Conflicts.reset (); reset_except_context () let prepare_for_printing tyl = @@ -1015,28 +1097,30 @@ let add_type_to_preparation = prepare_type (* Disabled in classic mode when printing an unification error *) let print_labels = ref true +let alias_nongen_row mode px ty = + match get_desc ty with + | Tvariant _ | Tobject _ -> + if is_non_gen mode (Transient_expr.type_expr px) then + add_alias_proxy px + | _ -> () + let rec tree_of_typexp mode ty = let px = proxy ty in if List.memq px !printed_aliases && not (List.memq px !delayed) then - let mark = is_non_gen mode ty in - let name = Names.name_of_type - (if mark then Names.new_weak_name ty else Names.new_name) - px - in - Otyp_var (mark, name) else + let non_gen = is_non_gen mode (Transient_expr.type_expr px) in + let name = Names.name_of_type (Names.new_var_name ~non_gen ty) px in + Otyp_var (non_gen, name) else let pr_typ () = let tty = Transient_expr.repr ty in match tty.desc with | Tvar _ -> let non_gen = is_non_gen mode ty in - let name_gen = - if non_gen then Names.new_weak_name ty else Names.new_name - in + let name_gen = Names.new_var_name ~non_gen ty in Otyp_var (non_gen, Names.name_of_type name_gen tty) | Tarrow(l, ty1, ty2, _) -> let lab = - if !print_labels || is_optional l then string_of_label l else "" + if !print_labels || is_optional l then l else Nolabel in let t1 = if is_optional l then @@ -1052,12 +1136,13 @@ let rec tree_of_typexp mode ty = | Tconstr(p, tyl, _abbrev) -> begin match best_type_path p with | Nth n -> tree_of_typexp mode (apply_nth n tyl) - | Path(nso, p) -> + | Path(nso, p') -> + Internal_names.add p'; let tyl' = apply_subst_opt nso tyl in - Otyp_constr (tree_of_path Type p, tree_of_typlist mode tyl') + Otyp_constr (tree_of_path (Some Type) p', tree_of_typlist mode tyl') end | Tvariant row -> - let Row {fields; name; closed} = row_repr row in + let Row {fields; name; closed; _} = row_repr row in let fields = if closed then List.filter (fun (_, f) -> row_field_repr f <> Rabsent) @@ -1077,25 +1162,21 @@ let rec tree_of_typexp mode ty = match best_type_path p with | Nth n -> tree_of_typexp mode (apply_nth n tyl) | Path(s, p) -> - let id = tree_of_path Type p in + let id = tree_of_path (Some Type) p in let args = tree_of_typlist mode (apply_subst_opt s tyl) in Otyp_constr (id, args) in if closed && all_present then out_variant else - let non_gen = is_non_gen mode (Transient_expr.type_expr px) in let tags = if all_present then None else Some (List.map fst present) in - Otyp_variant (non_gen, Ovar_typ out_variant, closed, tags) + Otyp_variant (Ovar_typ out_variant, closed, tags) | _ -> - let non_gen = - not (closed && all_present) && - is_non_gen mode (Transient_expr.type_expr px) in let fields = List.map (tree_of_row_field mode) fields in let tags = if all_present then None else Some (List.map fst present) in - Otyp_variant (non_gen, Ovar_fields fields, closed, tags) + Otyp_variant (Ovar_fields fields, closed, tags) end | Tobject (fi, nm) -> tree_of_typobject mode fi !nm @@ -1134,12 +1215,17 @@ let rec tree_of_typexp mode ty = String.concat "." (Longident.flatten li), tree_of_typexp mode ty )) fl in - Otyp_module (tree_of_path Module_type p, fl) + Otyp_module (tree_of_path (Some Module_type) p, fl) in if List.memq px !delayed then delayed := List.filter ((!=) px) !delayed; + alias_nongen_row mode px ty; if is_aliased_proxy px && aliasable ty then begin - add_printed_alias_proxy px; - Otyp_alias (pr_typ (), Names.name_of_type Names.new_name px) end + let non_gen = is_non_gen mode (Transient_expr.type_expr px) in + add_printed_alias_proxy ~non_gen px; + (* add_printed_alias chose a name, thus the name generator + doesn't matter.*) + let alias = Names.name_of_type (Names.new_var_name ~non_gen ty) px in + Otyp_alias {non_gen; aliased = pr_typ (); alias } end else pr_typ () and tree_of_row_field mode (l, f) = @@ -1171,28 +1257,25 @@ and tree_of_typobject mode fi nm = List.sort (fun (n, _) (n', _) -> String.compare n n') present_fields in tree_of_typfields mode rest sorted_fields in - let (fields, rest) = pr_fields fi in - Otyp_object (fields, rest) - | Some (p, ty :: tyl) -> begin - let non_gen = is_non_gen mode ty in + let (fields, open_row) = pr_fields fi in + Otyp_object {fields; open_row} + | Some (p, _ty :: tyl) -> let args = tree_of_typlist mode tyl in - let p = best_type_path_simple p in - Otyp_class (non_gen, tree_of_path Type p, args) - end + let p' = best_type_path_simple p in + Otyp_class (tree_of_best_type_path p p', args) | _ -> fatal_error "Printtyp.tree_of_typobject" end and tree_of_typfields mode rest = function | [] -> - let rest = + let open_row = match get_desc rest with - | Tvar _ | Tunivar _ -> Some (is_non_gen mode rest) - | Tconstr _ -> Some false - | Tnil -> None + | Tvar _ | Tunivar _ | Tconstr _-> true + | Tnil -> false | _ -> fatal_error "typfields (1)" in - ([], rest) + ([], open_row) | (s, t) :: l -> let field = (s, tree_of_typexp mode t) in let (fields, rest) = tree_of_typfields mode rest l in @@ -1202,6 +1285,7 @@ let typexp mode ppf ty = !Oprint.out_type ppf (tree_of_typexp mode ty) let prepared_type_expr ppf ty = typexp Type ppf ty +let prepared_type_scheme ppf ty = typexp Type_scheme ppf ty let type_expr ppf ty = (* [type_expr] is used directly by error message printers, @@ -1222,11 +1306,11 @@ let shared_type_scheme ppf ty = let type_scheme ppf ty = prepare_for_printing [ty]; - typexp Type_scheme ppf ty + prepared_type_scheme ppf ty let type_path ppf p = let p = best_class_type_path_simple p in - let t = tree_of_path Type p in + let t = tree_of_path (Some Type) p in !Oprint.out_ident ppf t let tree_of_type_scheme ty = @@ -1263,12 +1347,38 @@ let prepare_type_constructor_arguments = function | Cstr_tuple l -> List.iter prepare_type l | Cstr_record l -> List.iter (fun l -> prepare_type l.ld_type) l -let rec tree_of_type_decl id decl = +let tree_of_label l = + (Ident.name l.ld_id, l.ld_mutable = Mutable, tree_of_typexp Type l.ld_type) - reset_except_context(); +let tree_of_constructor_arguments = function + | Cstr_tuple l -> tree_of_typlist Type l + | Cstr_record l -> [ Otyp_record (List.map tree_of_label l) ] - let params = filter_params decl.type_params in +let tree_of_single_constructor cd = + let name = Ident.name cd.cd_id in + let ret = Option.map (tree_of_typexp Type) cd.cd_res in + let args = tree_of_constructor_arguments cd.cd_args in + { + ocstr_name = name; + ocstr_args = args; + ocstr_return_type = ret; + } +(* When printing GADT constructor, we need to forget the naming decision we took + for the type parameters and constraints. Indeed, in + {[ + type 'a t = X: 'a -> 'b t + ]} + It is fine to print both the type parameter ['a] and the existentially + quantified ['a] in the definition of the constructor X as ['a] + *) +let tree_of_constructor_in_decl cd = + match cd.cd_res with + | None -> tree_of_single_constructor cd + | Some _ -> Names.with_local_names (fun () -> tree_of_single_constructor cd) + +let prepare_decl id decl = + let params = filter_params decl.type_params in begin match decl.type_manifest with | Some ty -> let vars = free_variables ty in @@ -1279,10 +1389,9 @@ let rec tree_of_type_decl id decl = params | None -> () end; - List.iter add_alias params; List.iter prepare_type params; - List.iter add_printed_alias params; + List.iter (add_printed_alias ~non_gen:false) params; let ty_manifest = match decl.type_manifest with | None -> None @@ -1302,7 +1411,7 @@ let rec tree_of_type_decl id decl = Some ty in begin match decl.type_kind with - | Type_abstract -> () + | Type_abstract _ -> () | Type_variant (cstrs, _rep) -> List.iter (fun c -> @@ -1313,16 +1422,19 @@ let rec tree_of_type_decl id decl = List.iter (fun l -> prepare_type l.ld_type) l | Type_open -> () end; + ty_manifest, params - let type_param = +let tree_of_type_decl id decl = + let ty_manifest, params = prepare_decl id decl in + let type_param ot_variance = function - | Otyp_var (_, id) -> id - | _ -> "?" + | Otyp_var (ot_non_gen, ot_name) -> {ot_non_gen; ot_name; ot_variance} + | _ -> {ot_non_gen=false; ot_name="?"; ot_variance} in let type_defined decl = let abstr = match decl.type_kind with - Type_abstract -> + Type_abstract _ -> decl.type_manifest = None || decl.type_private = Private | Type_record _ -> decl.type_private = Private @@ -1338,7 +1450,7 @@ let rec tree_of_type_decl id decl = let is_var = is_Tvar ty in if abstr || not is_var then let inj = - decl.type_kind = Type_abstract && Variance.mem Inj v && + type_kind_is_abstract decl && Variance.mem Inj v && match decl.type_manifest with | None -> true | Some ty -> (* only abstract or private row types *) @@ -1352,7 +1464,7 @@ let rec tree_of_type_decl id decl = decl.type_params decl.type_variance in (Ident.name id, - List.map2 (fun ty cocn -> type_param (tree_of_typexp Type ty), cocn) + List.map2 (fun ty cocn -> type_param cocn (tree_of_typexp Type ty)) params vari) in let tree_of_manifest ty1 = @@ -1364,14 +1476,15 @@ let rec tree_of_type_decl id decl = let constraints = tree_of_constraints params in let ty, priv, unboxed = match decl.type_kind with - | Type_abstract -> + | Type_abstract _ -> begin match ty_manifest with | None -> (Otyp_abstract, Public, false) | Some ty -> tree_of_typexp Type ty, decl.type_private, false end | Type_variant (cstrs, rep) -> - tree_of_manifest (Otyp_sum (List.map tree_of_constructor cstrs)), + tree_of_manifest + (Otyp_sum (List.map tree_of_constructor_in_decl cstrs)), decl.type_private, (rep = Variant_unboxed) | Type_record(lbls, rep) -> @@ -1391,37 +1504,27 @@ let rec tree_of_type_decl id decl = otype_unboxed = unboxed; otype_cstrs = constraints } -and tree_of_constructor_arguments = function - | Cstr_tuple l -> tree_of_typlist Type l - | Cstr_record l -> [ Otyp_record (List.map tree_of_label l) ] +let add_type_decl_to_preparation id decl = + ignore @@ prepare_decl id decl -and tree_of_constructor cd = - let name = Ident.name cd.cd_id in - let arg () = tree_of_constructor_arguments cd.cd_args in - match cd.cd_res with - | None -> { - ocstr_name = name; - ocstr_args = arg (); - ocstr_return_type = None; - } - | Some res -> - Names.with_local_names (fun () -> - let ret = tree_of_typexp Type res in - let args = arg () in - { - ocstr_name = name; - ocstr_args = args; - ocstr_return_type = Some ret; - }) - -and tree_of_label l = - (Ident.name l.ld_id, l.ld_mutable = Mutable, tree_of_typexp Type l.ld_type) +let tree_of_prepared_type_decl id decl = + tree_of_type_decl id decl + +let tree_of_type_decl id decl = + reset_except_context(); + tree_of_type_decl id decl + +let add_constructor_to_preparation c = + prepare_type_constructor_arguments c.cd_args; + Option.iter prepare_type c.cd_res + +let prepared_constructor ppf c = + !Oprint.out_constr ppf (tree_of_single_constructor c) let constructor ppf c = reset_except_context (); - prepare_type_constructor_arguments c.cd_args; - Option.iter prepare_type c.cd_res; - !Oprint.out_constr ppf (tree_of_constructor c) + add_constructor_to_preparation c; + prepared_constructor ppf c let label ppf l = reset_except_context (); @@ -1431,9 +1534,19 @@ let label ppf l = let tree_of_type_declaration id decl rs = Osig_type (tree_of_type_decl id decl, tree_of_rec rs) +let tree_of_prepared_type_declaration id decl rs = + Osig_type (tree_of_prepared_type_decl id decl, tree_of_rec rs) + let type_declaration id ppf decl = !Oprint.out_sig_item ppf (tree_of_type_declaration id decl Trec_first) +let add_type_declaration_to_preparation id decl = + add_type_decl_to_preparation id decl + +let prepared_type_declaration id ppf decl = + !Oprint.out_sig_item ppf + (tree_of_prepared_type_declaration id decl Trec_first) + let constructor_arguments ppf a = let tys = tree_of_constructor_arguments a in !Oprint.out_type ppf (Otyp_tuple tys) @@ -1441,31 +1554,62 @@ let constructor_arguments ppf a = (* Print an extension declaration *) let extension_constructor_args_and_ret_type_subtree ext_args ext_ret_type = - match ext_ret_type with - | None -> (tree_of_constructor_arguments ext_args, None) - | Some res -> - Names.with_local_names (fun () -> - let ret = tree_of_typexp Type res in - let args = tree_of_constructor_arguments ext_args in - (args, Some ret)) - -let tree_of_extension_constructor id ext es = - reset_except_context (); - let type_path = best_type_path_simple ext.ext_type_path in - let ty_name = Path.name type_path in + let ret = Option.map (tree_of_typexp Type) ext_ret_type in + let args = tree_of_constructor_arguments ext_args in + (args, ret) + +(* When printing extension constructor, it is important to ensure that +after printing the constructor, we are still in the scope of the constructor. +For GADT constructor, this can be done by printing the type parameters inside +their own isolated scope. This ensures that in +{[ + type 'b t += A: 'b -> 'b any t +]} +the type parameter `'b` is not bound when printing the type variable `'b` from +the constructor definition from the type parameter. + +Contrarily, for non-gadt constructor, we must keep the same scope for +the type parameters and the constructor because a type constraint may +have changed the name of the type parameter: +{[ +type -'a t = .. constraint 'a> = 'a +(* the universal 'a is here to steal the name 'a from the type parameter *) +type 'a t = X of 'a +]} *) + +let add_extension_constructor_to_preparation ext = let ty_params = filter_params ext.ext_type_params in List.iter add_alias ty_params; List.iter prepare_type ty_params; - List.iter add_printed_alias ty_params; prepare_type_constructor_arguments ext.ext_args; - Option.iter prepare_type ext.ext_ret_type; + Option.iter prepare_type ext.ext_ret_type + +let prepared_tree_of_extension_constructor + id ext es + = + let type_path = best_type_path_simple ext.ext_type_path in + let ty_name = Path.name type_path in + let ty_params = filter_params ext.ext_type_params in let type_param = function | Otyp_var (_, id) -> id | _ -> "?" in + let param_scope f = + match ext.ext_ret_type with + | None -> + (* normal constructor: same scope for parameters and the constructor *) + f () + | Some _ -> + (* gadt constructor: isolated scope for the type parameters *) + Names.with_local_names f + in let ty_params = - List.map (fun ty -> type_param (tree_of_typexp Type ty)) ty_params + param_scope + (fun () -> + List.iter (add_printed_alias ~non_gen:false) ty_params; + List.map (fun ty -> type_param (tree_of_typexp Type ty)) ty_params + ) in let name = Ident.name id in let args, ret = @@ -1489,9 +1633,18 @@ let tree_of_extension_constructor id ext es = in Osig_typext (ext, es) +let tree_of_extension_constructor id ext es = + reset_except_context (); + add_extension_constructor_to_preparation ext; + prepared_tree_of_extension_constructor id ext es + let extension_constructor id ppf ext = !Oprint.out_sig_item ppf (tree_of_extension_constructor id ext Text_first) +let prepared_extension_constructor id ppf ext = + !Oprint.out_sig_item ppf + (prepared_tree_of_extension_constructor id ext Text_first) + let extension_only_constructor id ppf ext = reset_except_context (); prepare_type_constructor_arguments ext.ext_args; @@ -1623,7 +1776,7 @@ let rec tree_of_class_type mode params = Octy_signature (self_ty, List.rev csil) | Cty_arrow (l, ty, cty) -> let lab = - if !print_labels || is_optional l then string_of_label l else "" + if !print_labels || is_optional l then l else Nolabel in let tr = if is_optional l then @@ -1640,11 +1793,11 @@ let class_type ppf cty = !Oprint.out_class_type ppf (tree_of_class_type Type [] cty) let tree_of_class_param param variance = - (match tree_of_typexp Type_scheme param with - Otyp_var (_, s) -> s - | _ -> "?"), - if is_Tvar param then Asttypes.(NoVariance, NoInjectivity) - else variance + let ot_variance = + if is_Tvar param then Asttypes.(NoVariance, NoInjectivity) else variance in + match tree_of_typexp Type_scheme param with + Otyp_var (ot_non_gen, ot_name) -> {ot_non_gen; ot_name; ot_variance} + | _ -> {ot_non_gen=false; ot_name="?"; ot_variance} let class_variance = let open Variance in let open Asttypes in @@ -1662,8 +1815,8 @@ let tree_of_class_declaration id cl rs = let px = proxy (Btype.self_type_row cl.cty_type) in List.iter prepare_type params; - List.iter add_printed_alias params; - if is_aliased_proxy px then add_printed_alias_proxy px; + List.iter (add_printed_alias ~non_gen:false) params; + if is_aliased_proxy px then add_printed_alias_proxy ~non_gen:false px; let vir_flag = cl.cty_new = None in Osig_class @@ -1684,8 +1837,8 @@ let tree_of_cltype_declaration id cl rs = let px = proxy (Btype.self_type_row cl.clty_type) in List.iter prepare_type params; - List.iter add_printed_alias params; - if is_aliased_proxy px then add_printed_alias_proxy px; + List.iter (add_printed_alias ~non_gen:false) params; + if is_aliased_proxy px then (add_printed_alias_proxy ~non_gen:false) px; let sign = Btype.signature_of_class_type cl.clty_type in let has_virtual_vars = @@ -1719,7 +1872,7 @@ let dummy = { type_params = []; type_arity = 0; - type_kind = Type_abstract; + type_kind = Type_abstract Definition; type_private = Public; type_manifest = None; type_variance = []; @@ -1770,7 +1923,7 @@ let add_sigitem env x = let rec tree_of_modtype ?(ellipsis=false) = function | Mty_ident p -> let p = best_module_type_path p in - Omty_ident (tree_of_path Module_type p) + Omty_ident (tree_of_path (Some Module_type) p) | Mty_signature sg -> Omty_signature (if ellipsis then [Osig_ellipsis] else tree_of_signature sg) @@ -1782,7 +1935,7 @@ let rec tree_of_modtype ?(ellipsis=false) = function Omty_functor (param, res) | Mty_alias p -> let p = best_module_path p in - Omty_alias (tree_of_path Module p) + Omty_alias (tree_of_path (Some Module) p) | Mty_for_hole -> Omty_hole and tree_of_functor_parameter = function @@ -1809,8 +1962,7 @@ and tree_of_signature_rec env' sg = let collect_trees_of_rec_group group = let env = !printing_env in let env', group_trees = - Naming_context.with_ctx - (fun () -> trees_of_recursive_sigitem_group env group) + trees_of_recursive_sigitem_group env group in set_printing_env env'; (env, group_trees) in @@ -1888,7 +2040,6 @@ let modtype_declaration id ppf decl = let print_items showval env x = Names.refresh_weak(); - reset_naming_context (); Conflicts.reset (); let extend_val env (sigitem,outcome) = outcome, showval env sigitem in let post_process (env,l) = List.map (extend_val env) l in @@ -1906,7 +2057,6 @@ let signature ppf sg = let printed_signature sourcefile ppf sg = (* we are tracking any collision event for warning 63 *) Conflicts.reset (); - reset_naming_context (); let t = tree_of_signature sg in if Warnings.(is_active @@ Erroneous_printed_signature "") && Conflicts.exists () @@ -1973,28 +2123,30 @@ let trees_of_type_expansion mode Errortrace.{ty = t; expanded = t'} = end let type_expansion ppf = function - | Same t -> !Oprint.out_type ppf t + | Same t -> Style.as_inline_code !Oprint.out_type ppf t | Diff(t,t') -> - fprintf ppf "@[<2>%a@ =@ %a@]" !Oprint.out_type t !Oprint.out_type t' + fprintf ppf "@[<2>%a@ =@ %a@]" + (Style.as_inline_code !Oprint.out_type) t + (Style.as_inline_code !Oprint.out_type) t' let trees_of_trace mode = List.map (Errortrace.map_diff (trees_of_type_expansion mode)) let trees_of_type_path_expansion (tp,tp') = - if Path.same tp tp' then Same(tree_of_path Type tp) else - Diff(tree_of_path Type tp, tree_of_path Type tp') + if Path.same tp tp' then Same(tree_of_path (Some Type) tp) else + Diff(tree_of_path (Some Type) tp, tree_of_path (Some Type) tp') let type_path_expansion ppf = function - | Same p -> !Oprint.out_ident ppf p + | Same p -> Style.as_inline_code !Oprint.out_ident ppf p | Diff(p,p') -> fprintf ppf "@[<2>%a@ =@ %a@]" - !Oprint.out_ident p - !Oprint.out_ident p' + (Style.as_inline_code !Oprint.out_ident) p + (Style.as_inline_code !Oprint.out_ident) p' let rec trace fst txt ppf = function | {Errortrace.got; expected} :: rem -> if not fst then fprintf ppf "@,"; - fprintf ppf "@[Type@;<1 2>%a@ %s@;<1 2>%a@] %a" + fprintf ppf "@[Type@;<1 2>%a@ %s@;<1 2>%a@]%a" type_expansion got txt type_expansion expected (trace false txt) rem | _ -> () @@ -2041,18 +2193,15 @@ let prepare_any_trace printing_status tr = let prepare_trace f tr = prepare_any_trace printing_status (Errortrace.map f tr) -(** Keep elements that are not [Diff _ ] and take the decision +(** Keep elements that are [Diff _ ] and take the decision for the last element, require a prepared trace *) -let rec filter_trace - (trace_format : 'variety trace_format) - keep_last - : ('a, 'variety) Errortrace.t -> _ = function +let rec filter_trace keep_last = function | [] -> [] | [Errortrace.Diff d as elt] when printing_status elt = Optional_refinement -> if keep_last then [d] else [] - | Errortrace.Diff d :: rem -> d :: filter_trace trace_format keep_last rem - | _ :: rem -> filter_trace trace_format keep_last rem + | Errortrace.Diff d :: rem -> d :: filter_trace keep_last rem + | _ :: rem -> filter_trace keep_last rem let type_path_list = Format.pp_print_list ~pp_sep:(fun ppf () -> Format.pp_print_break ppf 2 0) @@ -2082,9 +2231,10 @@ let may_prepare_expansion compact (Errortrace.{ty; expanded} as ty_exp) = reserve_names ty; Errortrace.{ty; expanded = ty} | _ -> prepare_expansion ty_exp -let print_path p = Format.dprintf "%a" !Oprint.out_ident (tree_of_path Type p) +let print_path p = + Format.dprintf "%a" !Oprint.out_ident (tree_of_path (Some Type) p) -let print_tag ppf = fprintf ppf "`%s" +let print_tag ppf s = Style.inline_code ppf ("`" ^ s) let print_tags = let comma ppf () = Format.fprintf ppf ",@ " in @@ -2110,13 +2260,17 @@ let explanation_diff env t3 t4 : (Format.formatter -> unit) option = when is_unit env ty1 && unifiable env ty2 t4 -> Some (fun ppf -> fprintf ppf - "@,@[Hint: Did you forget to provide `()' as argument?@]") + "@,@[@{Hint@}: Did you forget to provide %a as argument?@]" + Style.inline_code "()" + ) | _, Tarrow (_, ty1, ty2, _) when is_unit env ty1 && unifiable env t3 ty2 -> Some (fun ppf -> fprintf ppf - "@,@[Hint: Did you forget to wrap the expression using \ - `fun () ->'?@]") + "@,@[@{Hint@}: Did you forget to wrap the expression using \ + %a?@]" + Style.inline_code "fun () ->" + ) | _ -> None @@ -2124,7 +2278,8 @@ let explain_fixed_row_case ppf = function | Errortrace.Cannot_be_closed -> fprintf ppf "it cannot be closed" | Errortrace.Cannot_add_tags tags -> - fprintf ppf "it may not allow the tag(s) %a" print_tags tags + fprintf ppf "it may not allow the tag(s) %a" + print_tags tags let explain_fixed_row pos expl = match expl with | Fixed_private -> @@ -2132,16 +2287,24 @@ let explain_fixed_row pos expl = match expl with | Univar x -> reserve_names x; dprintf "The %a variant type is bound to the universal type variable %a" - Errortrace.print_pos pos type_expr_with_reserved_names x + Errortrace.print_pos pos + (Style.as_inline_code type_expr_with_reserved_names) x | Reified p -> - dprintf "The %a variant type is bound to %t" - Errortrace.print_pos pos (print_path p) + dprintf "The %a variant type is bound to %a" + Errortrace.print_pos pos + (Style.as_inline_code + (fun ppf p -> + Internal_names.add p; + print_path p ppf)) + p | Rigid -> ignore let explain_variant (type variety) : variety Errortrace.variant -> _ = function (* Common *) | Errortrace.Incompatible_types_for s -> - Some(dprintf "@,Types for tag `%s are incompatible" s) + Some(dprintf "@,Types for tag %a are incompatible" + print_tag s + ) (* Unification *) | Errortrace.No_intersection -> Some(dprintf "@,These two variant types have no intersection") @@ -2164,9 +2327,9 @@ let explain_variant (type variety) : variety Errortrace.variant -> _ = function (* Equality & Moregen *) | Errortrace.Presence_not_guaranteed_for (pos, s) -> Some( dprintf - "@,@[The tag `%s is guaranteed to be present in the %a variant type,\ + "@,@[The tag %a is guaranteed to be present in the %a variant type,\ @ but not in the %a@]" - s + print_tag s Errortrace.print_pos (Errortrace.swap_position pos) Errortrace.print_pos pos ) @@ -2180,22 +2343,25 @@ let explain_escape pre = function reserve_names u; Some( dprintf "%t@,The universal variable %a would escape its scope" - pre type_expr_with_reserved_names u) + pre + (Style.as_inline_code type_expr_with_reserved_names) u + ) | Errortrace.Constructor p -> Some( dprintf "%t@,@[The type constructor@;<1 2>%a@ would escape its scope@]" - pre path p + pre (Style.as_inline_code path) p ) | Errortrace.Module_type p -> Some( dprintf "%t@,@[The module type@;<1 2>%a@ would escape its scope@]" - pre path p + pre (Style.as_inline_code path) p ) | Errortrace.Equation Errortrace.{ty = _; expanded = t} -> reserve_names t; Some( dprintf "%t @,@[This instance of %a is ambiguous:@ %s@]" - pre type_expr_with_reserved_names t + pre + (Style.as_inline_code type_expr_with_reserved_names) t "it would escape the scope of its equation" ) | Errortrace.Self -> @@ -2205,8 +2371,8 @@ let explain_escape pre = function let explain_object (type variety) : variety Errortrace.obj -> _ = function | Errortrace.Missing_field (pos,f) -> Some( - dprintf "@,@[The %a object type has no method %s@]" - Errortrace.print_pos pos f + dprintf "@,@[The %a object type has no method %a@]" + Errortrace.print_pos pos Style.inline_code f ) | Errortrace.Abstract_row pos -> Some( dprintf @@ -2216,6 +2382,15 @@ let explain_object (type variety) : variety Errortrace.obj -> _ = function | Errortrace.Self_cannot_be_closed -> Some (dprintf "@,Self type cannot be unified with a closed object type") +let explain_incompatible_fields name (diff: Types.type_expr Errortrace.diff) = + reserve_names diff.got; + reserve_names diff.expected; + dprintf "@,@[The method %a has type@ %a,@ \ + but the expected method type was@ %a@]" + Style.inline_code name + (Style.as_inline_code type_expr_with_reserved_names) diff.got + (Style.as_inline_code type_expr_with_reserved_names) diff.expected + let explanation (type variety) intro prev env : (Errortrace.expanded_type, variety) Errortrace.elt -> _ = function | Errortrace.Diff {got; expected} -> @@ -2225,20 +2400,15 @@ let explanation (type variety) intro prev env match context, kind, prev with | Some ctx, _, _ -> reserve_names ctx; - dprintf "@[%t@;<1 2>%a@]" intro type_expr_with_reserved_names ctx + dprintf "@[%t@;<1 2>%a@]" intro + (Style.as_inline_code type_expr_with_reserved_names) ctx | None, Univ _, Some(Errortrace.Incompatible_fields {name; diff}) -> - reserve_names diff.got; - reserve_names diff.expected; - dprintf "@,@[The method %s has type@ %a,@ \ - but the expected method type was@ %a@]" - name - type_expr_with_reserved_names diff.got - type_expr_with_reserved_names diff.expected + explain_incompatible_fields name diff | _ -> ignore in explain_escape pre kind - | Errortrace.Incompatible_fields { name; _ } -> - Some(dprintf "@,Types for method %s are incompatible" name) + | Errortrace.Incompatible_fields { name; diff} -> + Some(explain_incompatible_fields name diff) | Errortrace.Variant v -> explain_variant v | Errortrace.Obj o -> @@ -2253,7 +2423,8 @@ let explanation (type variety) intro prev env mark_loops x; mark_loops y; dprintf "@,@[The type variable %a occurs inside@ %a@]" - prepared_type_expr x prepared_type_expr y + (Style.as_inline_code prepared_type_expr) x + (Style.as_inline_code prepared_type_expr) y ppf) | _ -> (* We had a delayed unification of the type variable with @@ -2276,14 +2447,21 @@ let explain mis ppf = let warn_on_missing_def env ppf t = match get_desc t with | Tconstr (p,_,_) -> - begin - try - ignore(Env.find_type p env : Types.type_declaration) - with Not_found -> + begin match Env.find_type p env with + | exception Not_found -> fprintf ppf - "@,@[%a is abstract because no corresponding cmi file was found \ - in path.@]" path p - end + "@,@[Type %a is abstract because@ no corresponding\ + @ cmi file@ was found@ in path.@]" (Style.as_inline_code path) p + | { type_manifest = Some _; _ } -> () + | { type_manifest = None; _ } as decl -> + match type_origin decl with + | Rec_check_regularity -> + fprintf ppf + "@,@[Type %a was considered abstract@ when checking\ + @ constraints@ in this@ recursive type definition.@]" + (Style.as_inline_code path) p + | Definition | Existential _ -> () + end | _ -> () let prepare_expansion_head empty_tr = function @@ -2323,7 +2501,7 @@ let error trace_format mode subst env tr txt1 ppf txt2 ty_expect_explanation = | elt :: tr -> try print_labels := not !Clflags.classic; - let tr = filter_trace trace_format (mis = None) tr in + let tr = filter_trace (mis = None) tr in let head = prepare_expansion_head (tr=[]) elt in let tr = List.map (Errortrace.map_diff prepare_expansion) tr in let head_error = head_error_printer mode txt1 txt2 head in @@ -2338,6 +2516,7 @@ let error trace_format mode subst env tr txt1 ppf txt2 ty_expect_explanation = (explain mis); if env <> Env.empty then warn_on_missing_defs env ppf head; + Internal_names.print_explanations env ppf; Conflicts.print_explanations ppf; print_labels := true with exn -> @@ -2407,8 +2586,6 @@ module Subtype = struct print_labels := true; raise exn - let filter_unification_trace = filter_trace Unification - let rec filter_subtype_trace keep_last = function | [] -> [] | [Errortrace.Subtype.Diff d as elt] @@ -2444,7 +2621,7 @@ module Subtype = struct if tr_unif = [] then fprintf ppf "@]" else let mis = mismatch (dprintf "Within this type") env tr_unif in fprintf ppf "%a%t%t@]" - (trace filter_unification_trace unification_get_diff false + (trace filter_trace unification_get_diff false (mis = None) "is not compatible with type") tr_unif (explain mis) Conflicts.print_explanations @@ -2473,7 +2650,7 @@ let report_ambiguous_type_error ppf env tp0 tpl txt1 txt2 txt3 = txt3 type_path_expansion tp0) (* Adapt functions to exposed interface *) -let tree_of_path = tree_of_path Other +let tree_of_path = tree_of_path None let tree_of_modtype = tree_of_modtype ~ellipsis:false let type_expansion mode ppf ty_exp = type_expansion ppf (trees_of_type_expansion mode ty_exp) diff --git a/src/ocaml/typing/printtyp.mli b/src/ocaml/typing/printtyp.mli index 653abc8d14..2769fe0322 100644 --- a/src/ocaml/typing/printtyp.mli +++ b/src/ocaml/typing/printtyp.mli @@ -21,6 +21,7 @@ open Outcometree val longident: formatter -> Longident.t -> unit val ident: formatter -> Ident.t -> unit +val namespaced_ident: Shape.Sig_component_kind.t -> Ident.t -> string val tree_of_path: Path.t -> out_ident val path: formatter -> Path.t -> unit val string_of_path: Path.t -> string @@ -34,13 +35,7 @@ module Out_name: sig val print: out_name -> string end -type namespace = - | Type - | Module - | Module_type - | Class - | Class_type - | Other (** Other bypasses the unique name for identifier mechanism *) +type namespace := Shape.Sig_component_kind.t option val strings_of_paths: namespace -> Path.t list -> string list (** Print a list of paths, using the same naming context to @@ -62,9 +57,6 @@ module Naming_context: sig val enable: bool -> unit (** When contextual names are enabled, the mapping between identifiers and names is ensured to be one-to-one. *) - - val reset: unit -> unit - (** Reset the naming context *) end (** The [Conflicts] module keeps track of conflicts arising when attributing @@ -76,7 +68,7 @@ module Conflicts: sig an identifier to avoid a name collision *) type explanation = - { kind: namespace; + { kind: Shape.Sig_component_kind.t; name:string; root_name:string; location:Location.t @@ -132,6 +124,7 @@ val prepared_type_expr: formatter -> type_expr -> unit val constructor_arguments: formatter -> constructor_arguments -> unit val tree_of_type_scheme: type_expr -> out_type val type_scheme: formatter -> type_expr -> unit +val prepared_type_scheme: formatter -> type_expr -> unit val shared_type_scheme: formatter -> type_expr -> unit (** [shared_type_scheme] is very similar to [type_scheme], but does not reset the printing context first. This is intended to be used in cases where the @@ -142,12 +135,21 @@ val shared_type_scheme: formatter -> type_expr -> unit val tree_of_value_description: Ident.t -> value_description -> out_sig_item val value_description: Ident.t -> formatter -> value_description -> unit val label : formatter -> label_declaration -> unit +val add_constructor_to_preparation : constructor_declaration -> unit +val prepared_constructor : formatter -> constructor_declaration -> unit val constructor : formatter -> constructor_declaration -> unit val tree_of_type_declaration: Ident.t -> type_declaration -> rec_status -> out_sig_item +val add_type_declaration_to_preparation : + Ident.t -> type_declaration -> unit +val prepared_type_declaration: Ident.t -> formatter -> type_declaration -> unit val type_declaration: Ident.t -> formatter -> type_declaration -> unit val tree_of_extension_constructor: Ident.t -> extension_constructor -> ext_status -> out_sig_item +val add_extension_constructor_to_preparation : + extension_constructor -> unit +val prepared_extension_constructor: + Ident.t -> formatter -> extension_constructor -> unit val extension_constructor: Ident.t -> formatter -> extension_constructor -> unit (* Prints extension constructor with the type signature: diff --git a/src/ocaml/typing/printtyped.ml b/src/ocaml/typing/printtyped.ml index c3480379d2..28b973942e 100644 --- a/src/ocaml/typing/printtyped.ml +++ b/src/ocaml/typing/printtyped.ml @@ -13,18 +13,18 @@ (* *) (**************************************************************************) -open Asttypes;; -open Format;; -open Lexing;; -open Location;; -open Typedtree;; +open Asttypes +open Format +open Lexing +open Location +open Typedtree let fmt_position f l = if l.pos_lnum = -1 then fprintf f "%s[%d]" l.pos_fname l.pos_cnum else fprintf f "%s[%d,%d+%d]" l.pos_fname l.pos_lnum l.pos_bol (l.pos_cnum - l.pos_bol) -;; + let fmt_location f loc = if not !Clflags.locations then () @@ -32,17 +32,17 @@ let fmt_location f loc = fprintf f "(%a..%a)" fmt_position loc.loc_start fmt_position loc.loc_end; if loc.loc_ghost then fprintf f " ghost"; end -;; + let rec fmt_longident_aux f x = match x with | Longident.Lident (s) -> fprintf f "%s" s; | Longident.Ldot (y, s) -> fprintf f "%a.%s" fmt_longident_aux y s; | Longident.Lapply (y, z) -> - fprintf f "%a(%a)" fmt_longident_aux y fmt_longident_aux z; -;; + fprintf f "%a(%a)" fmt_longident_aux y fmt_longident_aux z -let fmt_longident f x = fprintf f "\"%a\"" fmt_longident_aux x.txt;; + +let fmt_longident f x = fprintf f "\"%a\"" fmt_longident_aux x.txt let fmt_ident = Ident.print @@ -52,45 +52,42 @@ let fmt_modname f = function let rec fmt_path_aux f x = match x with - | Path.Pident (s) -> fprintf f "%a" fmt_ident s; - | Path.Pdot (y, s) -> fprintf f "%a.%s" fmt_path_aux y s; + | Path.Pident (s) -> fprintf f "%a" fmt_ident s + | Path.Pdot (y, s) | Path.(Pextra_ty (y, Pcstr_ty s)) -> + fprintf f "%a.%s" fmt_path_aux y s | Path.Papply (y, z) -> - fprintf f "%a(%a)" fmt_path_aux y fmt_path_aux z; -;; + fprintf f "%a(%a)" fmt_path_aux y fmt_path_aux z + | Path.Pextra_ty (y, Pext_ty) -> fmt_path_aux f y -let fmt_path f x = fprintf f "\"%a\"" fmt_path_aux x;; +let fmt_path f x = fprintf f "\"%a\"" fmt_path_aux x let fmt_constant f x = match x with - | Const_int (i) -> fprintf f "Const_int %d" i; - | Const_char (c) -> fprintf f "Const_char %02x" (Char.code c); + | Const_int (i) -> fprintf f "Const_int %d" i + | Const_char (c) -> fprintf f "Const_char %02x" (Char.code c) | Const_string (s, strloc, None) -> - fprintf f "Const_string(%S,%a,None)" s fmt_location strloc; + fprintf f "Const_string(%S,%a,None)" s fmt_location strloc | Const_string (s, strloc, Some delim) -> - fprintf f "Const_string (%S,%a,Some %S)" s fmt_location strloc delim; - | Const_float (s) -> fprintf f "Const_float %s" s; - | Const_int32 (i) -> fprintf f "Const_int32 %ld" i; - | Const_int64 (i) -> fprintf f "Const_int64 %Ld" i; - | Const_nativeint (i) -> fprintf f "Const_nativeint %nd" i; -;; + fprintf f "Const_string (%S,%a,Some %S)" s fmt_location strloc delim + | Const_float (s) -> fprintf f "Const_float %s" s + | Const_int32 (i) -> fprintf f "Const_int32 %ld" i + | Const_int64 (i) -> fprintf f "Const_int64 %Ld" i + | Const_nativeint (i) -> fprintf f "Const_nativeint %nd" i let fmt_mutable_flag f x = match x with - | Immutable -> fprintf f "Immutable"; - | Mutable -> fprintf f "Mutable"; -;; + | Immutable -> fprintf f "Immutable" + | Mutable -> fprintf f "Mutable" let fmt_virtual_flag f x = match x with - | Virtual -> fprintf f "Virtual"; - | Concrete -> fprintf f "Concrete"; -;; + | Virtual -> fprintf f "Virtual" + | Concrete -> fprintf f "Concrete" let fmt_override_flag f x = match x with - | Override -> fprintf f "Override"; - | Fresh -> fprintf f "Fresh"; -;; + | Override -> fprintf f "Override" + | Fresh -> fprintf f "Fresh" let fmt_closed_flag f x = match x with @@ -99,35 +96,35 @@ let fmt_closed_flag f x = let fmt_rec_flag f x = match x with - | Nonrecursive -> fprintf f "Nonrec"; - | Recursive -> fprintf f "Rec"; -;; + | Nonrecursive -> fprintf f "Nonrec" + | Recursive -> fprintf f "Rec" let fmt_direction_flag f x = match x with - | Upto -> fprintf f "Up"; - | Downto -> fprintf f "Down"; -;; + | Upto -> fprintf f "Up" + | Downto -> fprintf f "Down" let fmt_private_flag f x = match x with - | Public -> fprintf f "Public"; - | Private -> fprintf f "Private"; -;; + | Public -> fprintf f "Public" + | Private -> fprintf f "Private" + +let fmt_partiality f x = + match x with + | Total -> () + | Partial -> fprintf f " (Partial)" let line i f s (*...*) = fprintf f "%s" (String.make (2*i) ' '); fprintf f s (*...*) -;; let list i f ppf l = match l with - | [] -> line i ppf "[]\n"; + | [] -> line i ppf "[]\n" | _ :: _ -> line i ppf "[\n"; List.iter (f (i+1) ppf) l; - line i ppf "]\n"; -;; + line i ppf "]\n" let array i f ppf a = if Array.length a = 0 then @@ -137,27 +134,25 @@ let array i f ppf a = Array.iter (f (i+1) ppf) a; line i ppf "]\n" end -;; let option i f ppf x = match x with - | None -> line i ppf "None\n"; + | None -> line i ppf "None\n" | Some x -> line i ppf "Some\n"; - f (i+1) ppf x; -;; + f (i+1) ppf x -let longident i ppf li = line i ppf "%a\n" fmt_longident li;; -let string i ppf s = line i ppf "\"%s\"\n" s;; +let longident i ppf li = line i ppf "%a\n" fmt_longident li +let string i ppf s = line i ppf "\"%s\"\n" s let arg_label i ppf = function | Nolabel -> line i ppf "Nolabel\n" | Optional s -> line i ppf "Optional \"%s\"\n" s | Labelled s -> line i ppf "Labelled \"%s\"\n" s -;; + let typevars ppf vs = List.iter (fun x -> fprintf ppf " %a" Pprintast.tyvar x.txt) vs -;; + let record_representation i ppf = let open Types in function | Record_regular -> line i ppf "Record_regular\n" @@ -216,7 +211,7 @@ let rec core_type i ppf x = line i ppf "Ttyp_class %a\n" fmt_path li; list i core_type ppf l; | Ttyp_alias (ct, s) -> - line i ppf "Ttyp_alias \"%s\"\n" s; + line i ppf "Ttyp_alias \"%s\"\n" s.txt; core_type i ppf ct; | Ttyp_poly (sl, ct) -> line i ppf "Ttyp_poly%a\n" @@ -225,6 +220,9 @@ let rec core_type i ppf x = | Ttyp_package { pack_path = s; pack_fields = l } -> line i ppf "Ttyp_package %a\n" fmt_path s; list i package_with ppf l; + | Ttyp_open (path, _mod_ident, t) -> + line i ppf "Ttyp_open %a\n" fmt_path path; + core_type i ppf t and package_with i ppf (s, t) = line i ppf "with type %a\n" fmt_longident s; @@ -242,8 +240,8 @@ and pattern : type k . _ -> _ -> k general_pattern -> unit = fun i ppf x -> end; match x.pat_desc with | Tpat_any -> line i ppf "Tpat_any\n"; - | Tpat_var (s,_) -> line i ppf "Tpat_var \"%a\"\n" fmt_ident s; - | Tpat_alias (p, s,_) -> + | Tpat_var (s,_,_) -> line i ppf "Tpat_var \"%a\"\n" fmt_ident s; + | Tpat_alias (p, s,_,_) -> line i ppf "Tpat_alias \"%a\"\n" fmt_ident s; pattern i ppf p; | Tpat_constant (c) -> line i ppf "Tpat_constant %a\n" fmt_constant c; @@ -298,7 +296,22 @@ and pattern_extra i ppf (extra_pat, _, attrs) = line i ppf "Tpat_extra_open %a\n" fmt_path id; attributes i ppf attrs; -and expression_extra i ppf (x,_,attrs) = +and function_body i ppf (body : function_body) = + match[@warning "+9"] body with + | Tfunction_body e -> + line i ppf "Tfunction_body\n"; + expression (i+1) ppf e + | Tfunction_cases + { cases; loc; exp_extra; attributes = attrs; param = _; partial } + -> + line i ppf "Tfunction_cases%a %a\n" + fmt_partiality partial + fmt_location loc; + attributes (i+1) ppf attrs; + Option.iter (fun e -> expression_extra (i+1) ppf e []) exp_extra; + list (i+1) case ppf cases + +and expression_extra i ppf x attrs = match x with | Texp_constraint ct -> line i ppf "Texp_constraint\n"; @@ -315,7 +328,7 @@ and expression_extra i ppf (x,_,attrs) = option i core_type ppf cto; | Texp_newtype s -> line i ppf "Texp_newtype \"%s\"\n" s; - | Texp_newtype' (id, _) -> + | Texp_newtype' (id, _, _) -> line i ppf "Texp_newtype' \"%a\"\n" fmt_ident id; attributes i ppf attrs; @@ -327,7 +340,7 @@ and expression i ppf x = | [] -> () | extra -> line i ppf "extra\n"; - List.iter (expression_extra (i+1) ppf) extra; + List.iter (fun (x, _, attrs) -> expression_extra (i+1) ppf x attrs) extra; end; match x.exp_desc with | Texp_ident (li,_,_) -> line i ppf "Texp_ident %a\n" fmt_path li; @@ -335,18 +348,19 @@ and expression i ppf x = | Texp_constant (c) -> line i ppf "Texp_constant %a\n" fmt_constant c; | Texp_let (rf, l, e) -> line i ppf "Texp_let %a\n" fmt_rec_flag rf; - list i value_binding ppf l; + list i (value_binding rf) ppf l; expression i ppf e; - | Texp_function { arg_label = p; param = _; cases; partial = _; } -> + | Texp_function (params, body) -> line i ppf "Texp_function\n"; - arg_label i ppf p; - list i case ppf cases; + list i function_param ppf params; + function_body i ppf body; | Texp_apply (e, l) -> line i ppf "Texp_apply\n"; expression i ppf e; list i label_x_expression ppf l; - | Texp_match (e, l, _partial) -> - line i ppf "Texp_match\n"; + | Texp_match (e, l, partial) -> + line i ppf "Texp_match%a\n" + fmt_partiality partial; expression i ppf e; list i case ppf l; | Texp_try (e, l) -> @@ -425,7 +439,7 @@ and expression i ppf x = line i ppf "Texp_letexception\n"; extension_constructor i ppf cd; expression i ppf e; - | Texp_assert (e) -> + | Texp_assert (e, _) -> line i ppf "Texp_assert"; expression i ppf e; | Texp_lazy (e) -> @@ -437,8 +451,9 @@ and expression i ppf x = | Texp_pack me -> line i ppf "Texp_pack"; module_expr i ppf me - | Texp_letop {let_; ands; param = _; body; partial = _} -> - line i ppf "Texp_letop"; + | Texp_letop {let_; ands; param = _; body; partial } -> + line i ppf "Texp_letop%a" + fmt_partiality partial; binding_op (i+1) ppf let_; list (i+1) binding_op ppf ands; case i ppf body @@ -467,6 +482,20 @@ and binding_op i ppf x = fmt_location x.bop_loc; expression i ppf x.bop_exp +and function_param i ppf x = + let p = x.fp_arg_label in + arg_label i ppf p; + match x.fp_kind with + | Tparam_pat pat -> + line i ppf "Param_pat%a\n" + fmt_partiality x.fp_partial; + pattern (i+1) ppf pat + | Tparam_optional_default (pat, expr) -> + line i ppf "Param_optional_default%a\n" + fmt_partiality x.fp_partial; + pattern (i+1) ppf pat; + expression (i+1) ppf expr + and type_parameter i ppf (x, _variance) = core_type i ppf x and type_declaration i ppf x = @@ -628,7 +657,7 @@ and class_expr i ppf x = list i label_x_expression ppf l; | Tcl_let (rf, l1, l2, ce) -> line i ppf "Tcl_let %a\n" fmt_rec_flag rf; - list i value_binding ppf l1; + list i (value_binding rf) ppf l1; list i ident_x_expression_def ppf l2; class_expr i ppf ce; | Tcl_constraint (ce, Some ct, _, _, _) -> @@ -825,6 +854,9 @@ and module_expr i ppf x = line i ppf "Tmod_apply\n"; module_expr i ppf me1; module_expr i ppf me2; + | Tmod_apply_unit me1 -> + line i ppf "Tmod_apply_unit\n"; + module_expr i ppf me1; | Tmod_constraint (me, _, Tmodtype_explicit mt, _) -> line i ppf "Tmod_constraint\n"; module_expr i ppf me; @@ -846,7 +878,7 @@ and structure_item i ppf x = expression i ppf e; | Tstr_value (rf, l) -> line i ppf "Tstr_value %a\n" fmt_rec_flag rf; - list i value_binding ppf l; + list i (value_binding rf) ppf l; | Tstr_primitive vd -> line i ppf "Tstr_primitive\n"; value_description i ppf vd; @@ -932,8 +964,12 @@ and case end; expression (i+1) ppf c_rhs; -and value_binding i ppf x = - line i ppf "\n"; +and value_binding rec_flag i ppf x = + begin match rec_flag, x.vb_rec_kind with + | Nonrecursive, _ -> line i ppf "\n" + | Recursive, Static -> line i ppf "\n" + | Recursive, Dynamic -> line i ppf "\n" + end; attributes (i+1) ppf x.vb_attributes; pattern (i+1) ppf x.vb_pat; expression (i+1) ppf x.vb_expr @@ -967,11 +1003,13 @@ and label_x_bool_x_core_type_list i ppf x = | Tinherit (ct) -> line i ppf "Tinherit\n"; core_type (i+1) ppf ct -;; -let interface ppf x = list 0 signature_item ppf x.sig_items;; -let implementation ppf x = list 0 structure_item ppf x.str_items;; +let interface ppf x = list 0 signature_item ppf x.sig_items + +let implementation ppf x = list 0 structure_item ppf x.str_items let implementation_with_coercion ppf Typedtree.{structure; _} = implementation ppf structure + +let expression ppf x = expression 0 ppf x diff --git a/src/ocaml/typing/printtyped.mli b/src/ocaml/typing/printtyped.mli index 7002986d4a..1150e2e16c 100644 --- a/src/ocaml/typing/printtyped.mli +++ b/src/ocaml/typing/printtyped.mli @@ -13,14 +13,15 @@ (* *) (**************************************************************************) -open Typedtree;; -open Format;; +open Typedtree +open Format -val interface : formatter -> signature -> unit;; -val implementation : formatter -> structure -> unit;; +val interface : formatter -> signature -> unit +val implementation : formatter -> structure -> unit val implementation_with_coercion : - formatter -> Typedtree.implementation -> unit;; + formatter -> Typedtree.implementation -> unit (* Added by merlin for debugging purposes *) val pattern : int -> formatter -> _ general_pattern -> unit +val expression : formatter -> expression -> unit diff --git a/src/ocaml/typing/shape.ml b/src/ocaml/typing/shape.ml index 8bd04f4dd5..2657058229 100644 --- a/src/ocaml/typing/shape.ml +++ b/src/ocaml/typing/shape.ml @@ -67,6 +67,8 @@ module Sig_component_kind = struct type t = | Value | Type + | Constructor + | Label | Module | Module_type | Extension_constructor @@ -76,6 +78,8 @@ module Sig_component_kind = struct let to_string = function | Value -> "value" | Type -> "type" + | Constructor -> "constructor" + | Label -> "label" | Module -> "module" | Module_type -> "module type" | Extension_constructor -> "extension constructor" @@ -87,6 +91,8 @@ module Sig_component_kind = struct | Extension_constructor -> false | Type + | Constructor + | Label | Module | Module_type | Class @@ -99,10 +105,15 @@ module Item = struct type t = string * Sig_component_kind.t let compare = compare + let name (name, _) = name + let kind (_, kind) = kind + let make str ns = str, ns let value id = Ident.name id, Sig_component_kind.Value let type_ id = Ident.name id, Sig_component_kind.Type + let constr id = Ident.name id, Sig_component_kind.Constructor + let label id = Ident.name id, Sig_component_kind.Label let module_ id = Ident.name id, Sig_component_kind.Module let module_type id = Ident.name id, Sig_component_kind.Module_type let extension_constructor id = @@ -124,27 +135,42 @@ module Item = struct end type var = Ident.t -type t = { uid: Uid.t option; desc: desc } +type t = { uid: Uid.t option; desc: desc; approximated: bool } and desc = | Var of var | Abs of var * t | App of t * t | Struct of t Item.Map.t + | Alias of t | Leaf | Proj of t * Item.t | Comp_unit of string + | Error of string -let print fmt = +let print fmt t = let print_uid_opt = Format.pp_print_option (fun fmt -> Format.fprintf fmt "<%a>" Uid.print) in let rec aux fmt { uid; desc } = match desc with | Var id -> - Format.fprintf fmt "%a%a" Ident.print id print_uid_opt uid + Format.fprintf fmt "%s%a" (Ident.name id) print_uid_opt uid | Abs (id, t) -> + let rec collect_idents = function + | { uid = None; desc = Abs(id, t) } -> + let (ids, body) = collect_idents t in + id :: ids, body + | body -> + ([], body) + in + let (other_idents, body) = collect_idents t in + let pp_idents fmt idents = + let idents_names = List.map Ident.name idents in + let pp_sep fmt () = Format.fprintf fmt ",@ " in + Format.pp_print_list ~pp_sep Format.pp_print_string fmt idents_names + in Format.fprintf fmt "Abs@[%a@,(@[%a,@ @[%a@]@])@]" - print_uid_opt uid Ident.print id aux t + print_uid_opt uid pp_idents (id :: other_idents) aux body | App (t1, t2) -> Format.fprintf fmt "@[%a(@,%a)%a@]" aux t1 aux t2 print_uid_opt uid @@ -166,350 +192,107 @@ let print fmt = | Struct map -> let print_map fmt = Item.Map.iter (fun item t -> - Format.fprintf fmt "@[%a ->@ %a;@]@," + Format.fprintf fmt "@[%a ->@ %a;@]@," Item.print item aux t ) in - Format.fprintf fmt "{@[%a@,%a@]}" print_uid_opt uid print_map map + if Item.Map.is_empty map then + Format.fprintf fmt "@[{%a}@]" print_uid_opt uid + else + Format.fprintf fmt "{@[%a@,%a@]}" print_uid_opt uid print_map map + | Alias t -> + Format.fprintf fmt "Alias@[(@[%a@,%a@])@]" print_uid_opt uid aux t + | Error s -> + Format.fprintf fmt "Error %s" s in - Format.fprintf fmt"@[%a@]@;" aux + if t.approximated then + Format.fprintf fmt "@[(approx)@ %a@]@;" aux t + else + Format.fprintf fmt "@[%a@]@;" aux t + +let rec strip_head_aliases = function + | { desc = Alias t; _ } -> strip_head_aliases t + | t -> t let fresh_var ?(name="shape-var") uid = let var = Ident.create_local name in - var, { uid = Some uid; desc = Var var } + var, { uid = Some uid; desc = Var var; approximated = false } let for_unnamed_functor_param = Ident.create_local "()" let var uid id = - { uid = Some uid; desc = Var id } + { uid = Some uid; desc = Var id; approximated = false } let abs ?uid var body = - { uid; desc = Abs (var, body) } + { uid; desc = Abs (var, body); approximated = false } let str ?uid map = - { uid; desc = Struct map } + { uid; desc = Struct map; approximated = false } + +let alias ?uid t = + { uid; desc = Alias t; approximated = false} let leaf uid = - { uid = Some uid; desc = Leaf } + { uid = Some uid; desc = Leaf; approximated = false } + +let approx t = { t with approximated = true} let proj ?uid t item = match t.desc with | Leaf -> (* When stuck projecting in a leaf we propagate the leaf as a best effort *) - t + approx t | Struct map -> begin try Item.Map.find item map - with Not_found -> t (* ill-typed program *) + with Not_found -> approx t (* ill-typed program *) end | _ -> - { uid; desc = Proj (t, item) } + { uid; desc = Proj (t, item); approximated = false } let app ?uid f ~arg = - { uid; desc = App (f, arg) } + { uid; desc = App (f, arg); approximated = false } let decompose_abs t = match t.desc with | Abs (x, t) -> Some (x, t) | _ -> None - -module Make_reduce(Params : sig - type env - val fuel : int - val read_unit_shape : unit_name:string -> t option - val find_shape : env -> Ident.t -> t -end) = struct - (* We implement a strong call-by-need reduction, following an - evaluator from Nathanaelle Courant. *) - - type nf = { uid: Uid.t option; desc: nf_desc } - and nf_desc = - | NVar of var - | NApp of nf * nf - | NAbs of local_env * var * t * delayed_nf - | NStruct of delayed_nf Item.Map.t - | NProj of nf * Item.t - | NLeaf - | NComp_unit of string - | NoFuelLeft of desc - (* A type of normal forms for strong call-by-need evaluation. - The normal form of an abstraction - Abs(x, t) - is a closure - NAbs(env, x, t, dnf) - when [env] is the local environment, and [dnf] is a delayed - normal form of [t]. - - A "delayed normal form" is morally equivalent to (nf Lazy.t), but - we use a different representation that is compatible with - memoization (lazy values are not hashable/comparable by default - comparison functions): we represent a delayed normal form as - just a not-yet-computed pair [local_env * t] of a term in a - local environment -- we could also see this as a term under - an explicit substitution. This delayed thunked is "forced" - by calling the normalization function as usual, but duplicate - computations are precisely avoided by memoization. - *) - and delayed_nf = Thunk of local_env * t - - and local_env = delayed_nf option Ident.Map.t - (* When reducing in the body of an abstraction [Abs(x, body)], we - bind [x] to [None] in the environment. [Some v] is used for - actual substitutions, for example in [App(Abs(x, body), t)], when - [v] is a thunk that will evaluate to the normal form of [t]. *) - - let improve_uid uid (nf : nf) = - match nf.uid with - | Some _ -> nf - | None -> { nf with uid } - - let in_memo_table memo_table memo_key f arg = - match Hashtbl.find memo_table memo_key with - | res -> res - | exception Not_found -> - let res = f arg in - Hashtbl.replace memo_table memo_key res; - res - - type env = { - fuel: int ref; - global_env: Params.env; - local_env: local_env; - reduce_memo_table: (local_env * t, nf) Hashtbl.t; - read_back_memo_table: (nf, t) Hashtbl.t; - } - - let bind env var shape = - { env with local_env = Ident.Map.add var shape env.local_env } - - let rec reduce_ env t = - let memo_key = (env.local_env, t) in - in_memo_table env.reduce_memo_table memo_key (reduce__ env) t - (* Memoization is absolutely essential for performance on this - problem, because the normal forms we build can in some real-world - cases contain an exponential amount of redundancy. Memoization - can avoid the repeated evaluation of identical subterms, - providing a large speedup, but even more importantly it - implicitly shares the memory of the repeated results, providing - much smaller normal forms (that blow up again if printed back - as trees). A functor-heavy file from Irmin has its shape normal - form decrease from 100Mio to 2.5Mio when memoization is enabled. - - Note: the local environment is part of the memoization key, while - it is defined using a type Ident.Map.t of non-canonical balanced - trees: two maps could have exactly the same items, but be - balanced differently and therefore hash differently, reducing - the effectivenss of memoization. - This could in theory happen, say, with the two programs - (fun x -> fun y -> ...) - and - (fun y -> fun x -> ...) - having "the same" local environments, with additions done in - a different order, giving non-structurally-equal trees. Should we - define our own hash functions to provide robust hashing on - environments? - - We believe that the answer is "no": this problem does not occur - in practice. We can assume that identifiers are unique on valid - typedtree fragments (identifier "stamps" distinguish - binding positions); in particular the two program fragments above - in fact bind *distinct* identifiers x (with different stamps) and - different identifiers y, so the environments are distinct. If two - environments are structurally the same, they must correspond to - the evaluation evnrionments of two sub-terms that are under - exactly the same scope of binders. So the two environments were - obtained by the same term traversal, adding binders in the same - order, giving the same balanced trees: the environments have the - same hash. -*) - - and reduce__ ({fuel; global_env; local_env; _} as env) (t : t) = - let reduce env t = reduce_ env t in - let delay_reduce env t = Thunk (env.local_env, t) in - let force (Thunk (local_env, t)) = - reduce { env with local_env } t in - let return desc : nf = { uid = t.uid; desc } in - if !fuel < 0 then return (NoFuelLeft t.desc) - else - match t.desc with - | Comp_unit unit_name -> - begin match Params.read_unit_shape ~unit_name with - | Some t -> reduce env t - | None -> return (NComp_unit unit_name) - end - | App(f, arg) -> - let f = reduce env f in - begin match f.desc with - | NAbs(clos_env, var, body, _body_nf) -> - let arg = delay_reduce env arg in - let env = bind { env with local_env = clos_env } var (Some arg) in - reduce env body - |> improve_uid t.uid - | _ -> - let arg = reduce env arg in - return (NApp(f, arg)) - end - | Proj(str, item) -> - let str = reduce env str in - let nored () = return (NProj(str, item)) in - begin match str.desc with - | NStruct (items) -> - begin match Item.Map.find item items with - | exception Not_found -> nored () - | nf -> - force nf - |> improve_uid t.uid - end - | _ -> - nored () - end - | Abs(var, body) -> - let body_nf = delay_reduce (bind env var None) body in - return (NAbs(local_env, var, body, body_nf)) - | Var id -> - begin match Ident.Map.find id local_env with - (* Note: instead of binding abstraction-bound variables to - [None], we could unify it with the [Some v] case by - binding the bound variable [x] to [NVar x]. - - One reason to distinguish the situations is that we can - provide a different [Uid.t] location; for bound - variables, we use the [Uid.t] of the bound occurrence - (not the binding site), whereas for bound values we use - their binding-time [Uid.t]. *) - | None -> return (NVar id) - | Some def -> force def - | exception Not_found -> - match Params.find_shape global_env id with - | exception Not_found -> return (NVar id) - | res when res = t -> return (NVar id) - | res -> - decr fuel; - reduce env res - end - | Leaf -> return NLeaf - | Struct m -> - let mnf = Item.Map.map (delay_reduce env) m in - return (NStruct mnf) - - let rec read_back env (nf : nf) : t = - in_memo_table env.read_back_memo_table nf (read_back_ env) nf - (* The [nf] normal form we receive may contain a lot of internal - sharing due to the use of memoization in the evaluator. We have - to memoize here again, otherwise the sharing is lost by mapping - over the term as a tree. *) - - and read_back_ env (nf : nf) : t = - { uid = nf.uid; desc = read_back_desc env nf.desc } - - and read_back_desc env desc = - let read_back nf = read_back env nf in - let read_back_force (Thunk (local_env, t)) = - read_back (reduce_ { env with local_env } t) in - match desc with - | NVar v -> - Var v - | NApp (nft, nfu) -> - App(read_back nft, read_back nfu) - | NAbs (_env, x, _t, nf) -> - Abs(x, read_back_force nf) - | NStruct nstr -> - Struct (Item.Map.map read_back_force nstr) - | NProj (nf, item) -> - Proj (read_back nf, item) - | NLeaf -> Leaf - | NComp_unit s -> Comp_unit s - | NoFuelLeft t -> t - - (* When in Merlin we don't need to perform full shape reduction since we are - only interested by uid's stored at the "top-level" of the shape once the - projections have been done. *) - let weak_read_back env (nf : nf) : t = - let cache = Hashtbl.create 42 in - let rec weak_read_back env nf = - let memo_key = (env.local_env, nf) in - in_memo_table cache memo_key (weak_read_back_ env) nf - and weak_read_back_ env nf : t = - { uid = nf.uid; desc = weak_read_back_desc env nf.desc } - and weak_read_back_desc env desc : desc = - let weak_read_back_no_force (Thunk (_local_env, t)) = t in - match desc with - | NVar v -> - Var v - | NApp (nft, nfu) -> - App(weak_read_back env nft, weak_read_back env nfu) - | NAbs (_env, x, _t, nf) -> - Abs(x, weak_read_back_no_force nf) - | NStruct nstr -> - Struct (Item.Map.map weak_read_back_no_force nstr) - | NProj (nf, item) -> - Proj (read_back env nf, item) - | NLeaf -> Leaf - | NComp_unit s -> Comp_unit s - | NoFuelLeft t -> t - in weak_read_back env nf - - let reduce global_env t = - let fuel = ref Params.fuel in - let reduce_memo_table = Hashtbl.create 42 in - let read_back_memo_table = Hashtbl.create 42 in - let local_env = Ident.Map.empty in - let env = { - fuel; - global_env; - reduce_memo_table; - read_back_memo_table; - local_env; - } in - reduce_ env t |> read_back env - - let weak_reduce global_env t = - let fuel = ref Params.fuel in - let reduce_memo_table = Hashtbl.create 42 in - let read_back_memo_table = Hashtbl.create 42 in - let local_env = Ident.Map.empty in - let env = { - fuel; - global_env; - reduce_memo_table; - read_back_memo_table; - local_env; - } in - reduce_ env t |> weak_read_back env -end - -module Local_reduce = - (* Note: this definition with [type env = unit] is only suitable for - reduction of toplevel shapes -- shapes of compilation units, - where free variables are only Comp_unit names. If we wanted to - reduce shapes inside module signatures, we would need to take - a typing environment as parameter. *) - Make_reduce(struct - type env = unit - let fuel = 10 - let read_unit_shape ~unit_name:_ = None - let find_shape _env _id = raise Not_found - end) - -let local_reduce shape = - Local_reduce.reduce () shape - -let dummy_mod = { uid = None; desc = Struct Item.Map.empty } - -let of_path ~find_shape ~namespace = +let dummy_mod = + { uid = None; desc = Struct Item.Map.empty; approximated = false } + +let of_path ~find_shape ~namespace path = + (* We need to handle the following cases: + Path of constructor: + M.t.C + Path of label: + M.t.lbl + Path of label of inline record: + M.t.C.lbl *) let rec aux : Sig_component_kind.t -> Path.t -> t = fun ns -> function | Pident id -> find_shape ns id - | Pdot (path, name) -> proj (aux Module path) (name, ns) + | Pdot (path, name) -> + let namespace : Sig_component_kind.t = + match (ns : Sig_component_kind.t) with + | Constructor -> Type + | Label -> Type + | _ -> Module + in + proj (aux namespace path) (name, ns) | Papply (p1, p2) -> app (aux Module p1) ~arg:(aux Module p2) + | Pextra_ty (path, extra) -> begin + match extra with + Pcstr_ty name -> proj (aux Type path) (name, Constructor) + | Pext_ty -> aux Extension_constructor path + end in - aux namespace + aux namespace path let for_persistent_unit s = { uid = Some (Uid.of_compilation_unit_id (Ident.create_persistent s)); - desc = Comp_unit s } + desc = Comp_unit s; approximated = false } -let leaf_for_unpack = { uid = None; desc = Leaf } +let leaf_for_unpack = { uid = None; desc = Leaf; approximated = false } let set_uid_if_none t uid = match t.uid with @@ -529,11 +312,21 @@ module Map = struct let item = Item.value id in Item.Map.add item (proj shape item) t - let add_type t id uid = Item.Map.add (Item.type_ id) (leaf uid) t + let add_type t id shape = Item.Map.add (Item.type_ id) shape t let add_type_proj t id shape = let item = Item.type_ id in Item.Map.add item (proj shape item) t + let add_constr t id shape = Item.Map.add (Item.constr id) shape t + let add_constr_proj t id shape = + let item = Item.constr id in + Item.Map.add item (proj shape item) t + + let add_label t id uid = Item.Map.add (Item.label id) (leaf uid) t + let add_label_proj t id shape = + let item = Item.label id in + Item.Map.add item (proj shape item) t + let add_module t id shape = Item.Map.add (Item.module_ id) shape t let add_module_proj t id shape = let item = Item.module_ id in @@ -545,8 +338,8 @@ module Map = struct let item = Item.module_type id in Item.Map.add item (proj shape item) t - let add_extcons t id uid = - Item.Map.add (Item.extension_constructor id) (leaf uid) t + let add_extcons t id shape = + Item.Map.add (Item.extension_constructor id) shape t let add_extcons_proj t id shape = let item = Item.extension_constructor id in Item.Map.add item (proj shape item) t diff --git a/src/ocaml/typing/shape.mli b/src/ocaml/typing/shape.mli index 9740a3ad2d..01b31d2575 100644 --- a/src/ocaml/typing/shape.mli +++ b/src/ocaml/typing/shape.mli @@ -13,6 +13,47 @@ (* *) (**************************************************************************) +(** Shapes are an abstract representation of modules' implementations which + allow the tracking of definitions through functor applications and other + module-level operations. + + The Shape of a compilation unit is elaborated during typing, partially + reduced (without loading external shapes) and written to the [cmt] file. + + External tools can retrieve the definition of any value (or type, or module, + etc) by following this procedure: + + - Build the Shape corresponding to the value's path: + [let shape = Env.shape_of_path ~namespace env path] + + - Instantiate the [Shape_reduce.Make] functor with a way to load shapes from + external units and to looks for shapes in the environment (usually using + [Env.shape_of_path]). + + - Completely reduce the shape: + [let shape = My_reduce.(weak_)reduce env shape] + + - The [Uid.t] stored in the reduced shape should be the one of the + definition. However, if the [approximate] field of the reduced shape is + [true] then the [Uid.t] will not correspond to the definition, but to the + closest parent module's uid. This happens when Shape reduction gets stuck, + for example when hitting first-class modules. + + - The location of the definition can be easily found with the + [cmt_format.cmt_uid_to_decl] table of the corresponding compilation unit. + + See: + - {{: https://icfp22.sigplan.org/details/mlfamilyworkshop-2022-papers/10/Module-Shapes-for-Modern-Tooling } + the design document} + - {{: https://www.lix.polytechnique.fr/Labo/Gabriel.Scherer/research/shapes/2022-ml-workshop-shapes-talk.pdf } + a talk about the reduction strategy +*) + +(** A [Uid.t] is associated to every declaration in signatures and + implementations. They uniquely identify bindings in the program. When + associated with these bindings' locations they are useful to external tools + when trying to jump to an identifier's declaration or definition. They are + stored to that effect in the [uid_to_decl] table of cmt files. *) module Uid : sig type t = private | Compilation_unit of string @@ -36,6 +77,8 @@ module Sig_component_kind : sig type t = | Value | Type + | Constructor + | Label | Module | Module_type | Extension_constructor @@ -48,35 +91,49 @@ module Sig_component_kind : sig val can_appear_in_types : t -> bool end +(** Shape's items are elements of a structure or, in the case of constructors + and labels, elements of a record or variants definition seen as a structure. + These structures model module components and nested types' constructors and + labels. *) module Item : sig - type t + type t = string * Sig_component_kind.t + val name : t -> string + val kind : t -> Sig_component_kind.t val make : string -> Sig_component_kind.t -> t val value : Ident.t -> t val type_ : Ident.t -> t + val constr : Ident.t -> t + val label : Ident.t -> t val module_ : Ident.t -> t val module_type : Ident.t -> t val extension_constructor : Ident.t -> t val class_ : Ident.t -> t val class_type : Ident.t -> t + val print : Format.formatter -> t -> unit + module Map : Map.S with type key = t end type var = Ident.t -type t = { uid: Uid.t option; desc: desc } +type t = { uid: Uid.t option; desc: desc; approximated: bool } and desc = | Var of var | Abs of var * t | App of t * t | Struct of t Item.Map.t + | Alias of t | Leaf | Proj of t * Item.t | Comp_unit of string + | Error of string val print : Format.formatter -> t -> unit +val strip_head_aliases : t -> t + (* Smart constructors *) val for_unnamed_functor_param : var @@ -86,6 +143,7 @@ val var : Uid.t -> Ident.t -> t val abs : ?uid:Uid.t -> var -> t -> t val app : ?uid:Uid.t -> t -> arg:t -> t val str : ?uid:Uid.t -> t Item.Map.t -> t +val alias : ?uid:Uid.t -> t -> t val proj : ?uid:Uid.t -> t -> Item.t -> t val leaf : Uid.t -> t @@ -105,16 +163,22 @@ module Map : sig val add_value : t -> Ident.t -> Uid.t -> t val add_value_proj : t -> Ident.t -> shape -> t - val add_type : t -> Ident.t -> Uid.t -> t + val add_type : t -> Ident.t -> shape -> t val add_type_proj : t -> Ident.t -> shape -> t + val add_constr : t -> Ident.t -> shape -> t + val add_constr_proj : t -> Ident.t -> shape -> t + + val add_label : t -> Ident.t -> Uid.t -> t + val add_label_proj : t -> Ident.t -> shape -> t + val add_module : t -> Ident.t -> shape -> t val add_module_proj : t -> Ident.t -> shape -> t val add_module_type : t -> Ident.t -> Uid.t -> t val add_module_type_proj : t -> Ident.t -> shape -> t - val add_extcons : t -> Ident.t -> Uid.t -> t + val add_extcons : t -> Ident.t -> shape -> t val add_extcons_proj : t -> Ident.t -> shape -> t val add_class : t -> Ident.t -> Uid.t -> t @@ -131,28 +195,3 @@ val of_path : namespace:Sig_component_kind.t -> Path.t -> t val set_uid_if_none : t -> Uid.t -> t - -(** The [Make_reduce] functor is used to generate a reduction function for - shapes. - - It is parametrized by: - - an environment and a function to find shapes by path in that environment - - a function to load the shape of an external compilation unit - - some fuel, which is used to bound recursion when dealing with recursive - shapes introduced by recursive modules. (FTR: merlin currently uses a - fuel of 10, which seems to be enough for most practical examples) -*) -module Make_reduce(Context : sig - type env - - val fuel : int - - val read_unit_shape : unit_name:string -> t option - - val find_shape : env -> Ident.t -> t - end) : sig - val reduce : Context.env -> t -> t - val weak_reduce : Context.env -> t -> t -end - -val local_reduce : t -> t diff --git a/src/ocaml/typing/shape_reduce.ml b/src/ocaml/typing/shape_reduce.ml new file mode 100644 index 0000000000..00a0ec88aa --- /dev/null +++ b/src/ocaml/typing/shape_reduce.ml @@ -0,0 +1,342 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Ulysse Gérard, Thomas Refis, Tarides *) +(* Nathanaëlle Courant, OCamlPro *) +(* Gabriel Scherer, projet Picube, INRIA Paris *) +(* *) +(* Copyright 2021 Institut National de Recherche en Informatique et *) +(* en Automatique. *) +(* *) +(* All rights reserved. This file is distributed under the terms of *) +(* the GNU Lesser General Public License version 2.1, with the *) +(* special exception on linking described in the file LICENSE. *) +(* *) +(**************************************************************************) + +open Shape + +type result = + | Resolved of Uid.t + | Resolved_alias of Uid.t * result + | Unresolved of t + | Approximated of Uid.t option + | Internal_error_missing_uid + +let rec print_result fmt result = + match result with + | Resolved uid -> + Format.fprintf fmt "@[Resolved: %a@]@;" Uid.print uid + | Resolved_alias (uid, r) -> + Format.fprintf fmt "@[Alias: %a -> %a@]@;" + Uid.print uid print_result r + | Unresolved shape -> + Format.fprintf fmt "@[Unresolved: %a@]@;" print shape + | Approximated (Some uid) -> + Format.fprintf fmt "@[Approximated: %a@]@;" Uid.print uid + | Approximated None -> + Format.fprintf fmt "@[Approximated: No uid@]@;" + | Internal_error_missing_uid -> + Format.fprintf fmt "@[Missing uid@]@;" + + +let find_shape env id = + let namespace = Shape.Sig_component_kind.Module in + Env.shape_of_path ~namespace env (Pident id) + +module Make(Params : sig + val fuel : int + val read_unit_shape : unit_name:string -> t option +end) = struct + (* We implement a strong call-by-need reduction, following an + evaluator from Nathanaelle Courant. *) + + type nf = { uid: Uid.t option; desc: nf_desc; approximated: bool } + and nf_desc = + | NVar of var + | NApp of nf * nf + | NAbs of local_env * var * t * delayed_nf + | NStruct of delayed_nf Item.Map.t + | NAlias of delayed_nf + | NProj of nf * Item.t + | NLeaf + | NComp_unit of string + | NError of string + + (* A type of normal forms for strong call-by-need evaluation. + The normal form of an abstraction + Abs(x, t) + is a closure + NAbs(env, x, t, dnf) + when [env] is the local environment, and [dnf] is a delayed + normal form of [t]. + + A "delayed normal form" is morally equivalent to (nf Lazy.t), but + we use a different representation that is compatible with + memoization (lazy values are not hashable/comparable by default + comparison functions): we represent a delayed normal form as + just a not-yet-computed pair [local_env * t] of a term in a + local environment -- we could also see this as a term under + an explicit substitution. This delayed thunked is "forced" + by calling the normalization function as usual, but duplicate + computations are precisely avoided by memoization. + *) + and delayed_nf = Thunk of local_env * t + + and local_env = delayed_nf option Ident.Map.t + (* When reducing in the body of an abstraction [Abs(x, body)], we + bind [x] to [None] in the environment. [Some v] is used for + actual substitutions, for example in [App(Abs(x, body), t)], when + [v] is a thunk that will evaluate to the normal form of [t]. *) + + let approx_nf nf = { nf with approximated = true } + + let in_memo_table memo_table memo_key f arg = + match Hashtbl.find memo_table memo_key with + | res -> res + | exception Not_found -> + let res = f arg in + Hashtbl.replace memo_table memo_key res; + res + + type env = { + fuel: int ref; + global_env: Env.t; + local_env: local_env; + reduce_memo_table: (local_env * t, nf) Hashtbl.t; + read_back_memo_table: (nf, t) Hashtbl.t; + } + + let bind env var shape = + { env with local_env = Ident.Map.add var shape env.local_env } + + let rec reduce_ env t = + let local_env = env.local_env in + let memo_key = (local_env, t) in + in_memo_table env.reduce_memo_table memo_key (reduce__ env) t + (* Memoization is absolutely essential for performance on this + problem, because the normal forms we build can in some real-world + cases contain an exponential amount of redundancy. Memoization + can avoid the repeated evaluation of identical subterms, + providing a large speedup, but even more importantly it + implicitly shares the memory of the repeated results, providing + much smaller normal forms (that blow up again if printed back + as trees). A functor-heavy file from Irmin has its shape normal + form decrease from 100Mio to 2.5Mio when memoization is enabled. + + Note: the local environment is part of the memoization key, while + it is defined using a type Ident.Map.t of non-canonical balanced + trees: two maps could have exactly the same items, but be + balanced differently and therefore hash differently, reducing + the effectivenss of memoization. + This could in theory happen, say, with the two programs + (fun x -> fun y -> ...) + and + (fun y -> fun x -> ...) + having "the same" local environments, with additions done in + a different order, giving non-structurally-equal trees. Should we + define our own hash functions to provide robust hashing on + environments? + + We believe that the answer is "no": this problem does not occur + in practice. We can assume that identifiers are unique on valid + typedtree fragments (identifier "stamps" distinguish + binding positions); in particular the two program fragments above + in fact bind *distinct* identifiers x (with different stamps) and + different identifiers y, so the environments are distinct. If two + environments are structurally the same, they must correspond to + the evaluation evnrionments of two sub-terms that are under + exactly the same scope of binders. So the two environments were + obtained by the same term traversal, adding binders in the same + order, giving the same balanced trees: the environments have the + same hash. + *) + + and force env (Thunk (local_env, t)) = + reduce_ { env with local_env } t + + and reduce__ + ({fuel; global_env; local_env; _} as env) (t : t) = + let reduce env t = reduce_ env t in + let delay_reduce env t = Thunk (env.local_env, t) in + let return desc = { uid = t.uid; desc; approximated = t.approximated } in + let rec force_aliases nf = match nf.desc with + | NAlias delayed_nf -> + let nf = force env delayed_nf in + force_aliases nf + | _ -> nf + in + let reset_uid_if_new_binding t' = + match t.uid with + | None -> t' + | Some _ as uid -> { t' with uid } + in + if !fuel < 0 then approx_nf (return (NError "NoFuelLeft")) + else + match t.desc with + | Comp_unit unit_name -> + begin match Params.read_unit_shape ~unit_name with + | Some t -> reduce env t + | None -> return (NComp_unit unit_name) + end + | App(f, arg) -> + let f = reduce env f |> force_aliases in + begin match f.desc with + | NAbs(clos_env, var, body, _body_nf) -> + let arg = delay_reduce env arg in + let env = bind { env with local_env = clos_env } var (Some arg) in + reduce env body |> reset_uid_if_new_binding + | _ -> + let arg = reduce env arg in + return (NApp(f, arg)) + end + | Proj(str, item) -> + let str = reduce env str |> force_aliases in + let nored () = return (NProj(str, item)) in + begin match str.desc with + | NStruct (items) -> + begin match Item.Map.find item items with + | exception Not_found -> nored () + | nf -> force env nf |> reset_uid_if_new_binding + end + | _ -> + nored () + end + | Abs(var, body) -> + let body_nf = delay_reduce (bind env var None) body in + return (NAbs(local_env, var, body, body_nf)) + | Var id -> + begin match Ident.Map.find id local_env with + (* Note: instead of binding abstraction-bound variables to + [None], we could unify it with the [Some v] case by + binding the bound variable [x] to [NVar x]. + + One reason to distinguish the situations is that we can + provide a different [Uid.t] location; for bound + variables, we use the [Uid.t] of the bound occurrence + (not the binding site), whereas for bound values we use + their binding-time [Uid.t]. *) + | None -> return (NVar id) + | Some def -> + begin match force env def with + | { uid = Some _; _ } as nf -> nf + (* This var already has a binding uid *) + | { uid = None; _ } as nf -> { nf with uid = t.uid } + (* Set the var's binding uid *) + end + | exception Not_found -> + match find_shape global_env id with + | exception Not_found -> return (NVar id) + | res when res = t -> return (NVar id) + | res -> + decr fuel; + reduce env res + end + | Leaf -> return NLeaf + | Struct m -> + let mnf = Item.Map.map (delay_reduce env) m in + return (NStruct mnf) + | Alias t -> return (NAlias (delay_reduce env t)) + | Error s -> approx_nf (return (NError s)) + + and read_back env (nf : nf) : t = + in_memo_table env.read_back_memo_table nf (read_back_ env) nf + (* The [nf] normal form we receive may contain a lot of internal + sharing due to the use of memoization in the evaluator. We have + to memoize here again, otherwise the sharing is lost by mapping + over the term as a tree. *) + + and read_back_ env (nf : nf) : t = + { uid = nf.uid ; + desc = read_back_desc env nf.desc; + approximated = nf.approximated } + + and read_back_desc env desc = + let read_back nf = read_back env nf in + let read_back_force dnf = read_back (force env dnf) in + match desc with + | NVar v -> + Var v + | NApp (nft, nfu) -> + App(read_back nft, read_back nfu) + | NAbs (_env, x, _t, nf) -> + Abs(x, read_back_force nf) + | NStruct nstr -> + Struct (Item.Map.map read_back_force nstr) + | NAlias nf -> Alias (read_back_force nf) + | NProj (nf, item) -> + Proj (read_back nf, item) + | NLeaf -> Leaf + | NComp_unit s -> Comp_unit s + | NError s -> Error s + + (* Sharing the memo tables is safe at the level of a compilation unit since + idents should be unique *) + let reduce_memo_table = Hashtbl.create 42 + let read_back_memo_table = Hashtbl.create 42 + + let reduce global_env t = + let fuel = ref Params.fuel in + let local_env = Ident.Map.empty in + let env = { + fuel; + global_env; + reduce_memo_table = reduce_memo_table; + read_back_memo_table = read_back_memo_table; + local_env; + } in + reduce_ env t |> read_back env + + let rec is_stuck_on_comp_unit (nf : nf) = + match nf.desc with + | NVar _ -> + (* This should not happen if we only reduce closed terms *) + false + | NApp (nf, _) | NProj (nf, _) -> is_stuck_on_comp_unit nf + | NStruct _ | NAbs _ -> false + | NAlias _ -> false + | NComp_unit _ -> true + | NError _ -> false + | NLeaf -> false + + let rec reduce_aliases_for_uid env (nf : nf) = + match nf with + | { uid = Some uid; desc = NAlias dnf; approximated = false; _ } -> + let result = reduce_aliases_for_uid env (force env dnf) in + Resolved_alias (uid, result) + | { uid = Some uid; approximated = false; _ } -> Resolved uid + | { uid; approximated = true } -> Approximated uid + | { uid = None; approximated = false; _ } -> + (* A missing Uid after a complete reduction means the Uid was first + missing in the shape which is a code error. Having the + [Missing_uid] reported will allow Merlin (or another tool working + with the index) to ask users to report the issue if it does happen. + *) + Internal_error_missing_uid + + let reduce_for_uid global_env t = + let fuel = ref Params.fuel in + let local_env = Ident.Map.empty in + let env = { + fuel; + global_env; + reduce_memo_table = reduce_memo_table; + read_back_memo_table = read_back_memo_table; + local_env; + } in + let nf = reduce_ env t in + if is_stuck_on_comp_unit nf then + Unresolved (read_back env nf) + else + reduce_aliases_for_uid env nf +end + +module Local_reduce = + Make(struct + let fuel = 10 + let read_unit_shape ~unit_name:_ = None + end) + +let local_reduce = Local_reduce.reduce +let local_reduce_for_uid = Local_reduce.reduce_for_uid diff --git a/src/ocaml/typing/shape_reduce.mli b/src/ocaml/typing/shape_reduce.mli new file mode 100644 index 0000000000..307bc7683f --- /dev/null +++ b/src/ocaml/typing/shape_reduce.mli @@ -0,0 +1,62 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Ulysse Gérard, Thomas Refis, Tarides *) +(* Nathanaëlle Courant, OCamlPro *) +(* Gabriel Scherer, projet Picube, INRIA Paris *) +(* *) +(* Copyright 2021 Institut National de Recherche en Informatique et *) +(* en Automatique. *) +(* *) +(* All rights reserved. This file is distributed under the terms of *) +(* the GNU Lesser General Public License version 2.1, with the *) +(* special exception on linking described in the file LICENSE. *) +(* *) +(**************************************************************************) + +(** The result of reducing a shape and looking for its uid *) +type result = + | Resolved of Shape.Uid.t (** Shape reduction succeeded and a uid was found *) + | Resolved_alias of Shape.Uid.t * result (** Reduction led to an alias *) + | Unresolved of Shape.t (** Result still contains [Comp_unit] terms *) + | Approximated of Shape.Uid.t option + (** Reduction failed: it can arrive with first-class modules for example *) + | Internal_error_missing_uid + (** Reduction succeeded but no uid was found, this should never happen *) + +val print_result : Format.formatter -> result -> unit + +(** The [Make] functor is used to generate a reduction function for + shapes. + + It is parametrized by: + - a function to load the shape of an external compilation unit + - some fuel, which is used to bound recursion when dealing with recursive + shapes introduced by recursive modules. (FTR: merlin currently uses a + fuel of 10, which seems to be enough for most practical examples) + + Usage warning: To ensure good performances, every reduction made with the + same instance of that functor share the same ident-based memoization tables. + Such an instance should only be used to perform reduction inside a unique + compilation unit to prevent conflicting entries in these memoization tables. +*) +module Make(_ : sig + val fuel : int + + val read_unit_shape : unit_name:string -> Shape.t option + end) : sig + val reduce : Env.t -> Shape.t -> Shape.t + + (** Perform weak reduction and return the head's uid if any. If reduction was + incomplete the partially reduced shape is returned. *) + val reduce_for_uid : Env.t -> Shape.t -> result +end + +(** [local_reduce] will not reduce shapes that require loading external + compilation units. *) +val local_reduce : Env.t -> Shape.t -> Shape.t + +(** [local_reduce_for_uid] will not reduce shapes that require loading external + compilation units. *) +val local_reduce_for_uid : Env.t -> Shape.t -> result diff --git a/src/ocaml/typing/short_paths.ml b/src/ocaml/typing/short_paths.ml index efc423e375..9493afbf70 100644 --- a/src/ocaml/typing/short_paths.ml +++ b/src/ocaml/typing/short_paths.ml @@ -1531,6 +1531,7 @@ module Shortest = struct Application { kind; node; origin; best; min; max; func; arg; func_first; searched; finished } + | Path.Pextra_ty _ -> raise Not_found in loop kind canonical_path diff --git a/src/ocaml/typing/short_paths_graph.ml b/src/ocaml/typing/short_paths_graph.ml index 1b2fbde6ad..c3d9d8bfcd 100644 --- a/src/ocaml/typing/short_paths_graph.ml +++ b/src/ocaml/typing/short_paths_graph.ml @@ -25,42 +25,13 @@ module Path = struct | Pident of Ident.t | Pdot of t * string | Papply of t * t + | Pextra_ty of t * Path.extra_ty - open Path + (* open Path *) - let rec equal t1 t2 = - match t1, t2 with - | Pident id1, Pident id2 -> Ident.equal id1 id2 - | Pident _, Pdot _ -> false - | Pident _, Papply _ -> false - | Pdot _, Pident _ -> false - | Pdot(parent1, name1), Pdot(parent2, name2) -> - equal parent1 parent2 - && String.equal name1 name2 - | Pdot _, Papply _ -> false - | Papply _, Pident _ -> false - | Papply _, Pdot _ -> false - | Papply(func1, arg1), Papply(func2, arg2) -> - equal func1 func2 - && equal arg1 arg2 - - let rec compare t1 t2 = - match t1, t2 with - | Pident id1, Pident id2 -> Ident.compare id1 id2 - | Pident _, Pdot _ -> -1 - | Pident _, Papply _ -> -1 - | Pdot _, Pident _ -> 1 - | Pdot(parent1, name1), Pdot(parent2, name2) -> - let c = compare parent1 parent2 in - if c <> 0 then c - else String.compare name1 name2 - | Pdot _, Papply _ -> -1 - | Papply _, Pident _ -> 1 - | Papply _, Pdot _ -> 1 - | Papply(func1, arg1), Papply(func2, arg2) -> - let c = compare func1 func2 in - if c <> 0 then c - else compare arg1 arg2 + let equal t1 t2 = Path.same t1 t2 + + let compare t1 t2 = Path.compare t1 t2 end @@ -243,8 +214,11 @@ let hidden_name name = with Exit -> true let hidden_ident id = - if !Clflags.unsafe_string && Ident.equal id Predef.ident_bytes then true - else hidden_name (Ident.name id) + (* if !Clflags.unsafe_string && Ident.equal id Predef.ident_bytes then true + else + + Since 5.0.0 unsafe_string is always false *) + hidden_name (Ident.name id) let hidden_definition deprecated name = match deprecated with @@ -1387,6 +1361,8 @@ end = struct | Path.Papply(p, arg) -> let md = find_module t p in Module.find_application t md arg + | Path.Pextra_ty _ -> + raise Not_found let find_type t path = match path with @@ -1395,7 +1371,7 @@ end = struct | Path.Pdot(p, name) -> let md = find_module t p in Module.find_type t md name - | Path.Papply _ -> + | Path.Papply _ | Path.Pextra_ty _ -> raise Not_found let find_class_type t path = @@ -1405,7 +1381,7 @@ end = struct | Path.Pdot(p, name) -> let md = find_module t p in Module.find_class_type t md name - | Path.Papply _ -> + | Path.Papply _ | Path.Pextra_ty _ -> raise Not_found let find_module_type t path = @@ -1415,7 +1391,7 @@ end = struct | Path.Pdot(p, name) -> let md = find_module t p in Module.find_module_type t md name - | Path.Papply _ -> + | Path.Papply _ | Path.Pextra_ty _ -> raise Not_found let canonical_type_path t id = @@ -1455,7 +1431,7 @@ end = struct let rec is_module_path_visible t = function | Path.Pident id -> is_module_ident_visible t id - | Path.Pdot(path, _) -> + | Path.Pdot(path, _) | Pextra_ty (path, _) -> is_module_path_visible t path | Path.Papply(path1, path2) -> is_module_path_visible t path1 @@ -1478,7 +1454,7 @@ end = struct let is_type_path_visible t = function | Path.Pident id -> is_type_ident_visible t id - | Path.Pdot(path, _) -> is_module_path_visible t path + | Path.Pdot(path, _) | Pextra_ty (path, _) -> is_module_path_visible t path | Path.Papply _ -> failwith "Short_paths_graph.Graph.is_type_path_visible: \ @@ -1502,7 +1478,7 @@ end = struct let is_class_type_path_visible t = function | Path.Pident id -> is_class_type_ident_visible t id | Path.Pdot(path, _) -> is_module_path_visible t path - | Path.Papply _ -> + | Path.Papply _ | Path.Pextra_ty _ -> failwith "Short_paths_graph.Graph.is_class_type_path_visible: \ invalid class type path" @@ -1525,7 +1501,7 @@ end = struct let is_module_type_path_visible t = function | Path.Pident id -> is_module_type_ident_visible t id | Path.Pdot(path, _) -> is_module_path_visible t path - | Path.Papply _ -> + | Path.Papply _ | Path.Pextra_ty _ -> failwith "Short_paths_graph.Graph.is_module_type_path_visible: \ invalid module type path" diff --git a/src/ocaml/typing/short_paths_graph.mli b/src/ocaml/typing/short_paths_graph.mli index 5f02176416..82d02b04ca 100644 --- a/src/ocaml/typing/short_paths_graph.mli +++ b/src/ocaml/typing/short_paths_graph.mli @@ -34,6 +34,7 @@ module Path : sig | Pident of Ident.t | Pdot of t * string | Papply of t * t + | Pextra_ty of t * Path.extra_ty val equal : t -> t -> bool diff --git a/src/ocaml/typing/signature_group.ml b/src/ocaml/typing/signature_group.ml index b2cc7d4910..b98a9eb67f 100644 --- a/src/ocaml/typing/signature_group.ml +++ b/src/ocaml/typing/signature_group.ml @@ -46,16 +46,16 @@ let next_group = function match src with | Types.Sig_class _ -> (* a class declaration for [c] is followed by the ghost - declarations of class type [c], and types [c] and [#c] *) + declarations of class type [c], and type [c] *) begin match q with - | ct::t::ht::q -> [ct;t;ht], q + | ct::t::q -> [ct;t], q | _ -> assert false end | Types.Sig_class_type _ -> (* a class type declaration for [ct] is followed by the ghost - declarations of types [ct] and [#ct] *) + declaration of type [ct] *) begin match q with - | t::ht::q -> [t;ht], q + | t::q -> [t], q | _ -> assert false end | Types.(Sig_module _ | Sig_value _ | Sig_type _ | Sig_typext _ diff --git a/src/ocaml/typing/signature_group.mli b/src/ocaml/typing/signature_group.mli index 0b736a5b45..a84925db3b 100644 --- a/src/ocaml/typing/signature_group.mli +++ b/src/ocaml/typing/signature_group.mli @@ -73,9 +73,7 @@ type in_place_patch = { (** [!replace_in_place patch sg] replaces the first element of the signature - for which [patch ~rec_group ~ghosts component] returns [Some (value,patch)]. - The [rec_group] argument is the remaining part of the mutually - recursive group of [component]. + for which [patch ~ghosts component] returns [Some (value,patch)]. The [ghosts] list is the current prefix of ghost components associated to [component] *) diff --git a/src/ocaml/typing/stypes.ml b/src/ocaml/typing/stypes.ml index fed268f0d2..9d4a2ff70f 100644 --- a/src/ocaml/typing/stypes.ml +++ b/src/ocaml/typing/stypes.ml @@ -22,10 +22,10 @@ interesting in case of errors. *) -open Annot;; -open Lexing;; -open Location;; -open Typedtree;; +open Annot +open Lexing +open Location +open Typedtree let output_int oc i = output_string oc (Int.to_string i) @@ -36,7 +36,6 @@ type annotation = | Ti_mod of module_expr | An_call of Location.t * Annot.call | An_ident of Location.t * string * Annot.ident -;; let get_location ti = match ti with @@ -46,19 +45,16 @@ let get_location ti = | Ti_mod m -> m.mod_loc | An_call (l, _k) -> l | An_ident (l, _s, _k) -> l -;; -let annotations = ref ([] : annotation list);; -let phrases = ref ([] : Location.t list);; +let annotations = ref ([] : annotation list) +let phrases = ref ([] : Location.t list) let record ti = if !Clflags.annotations && not (get_location ti).Location.loc_ghost then annotations := ti :: !annotations -;; let record_phrase loc = - if !Clflags.annotations then phrases := loc :: !phrases; -;; + if !Clflags.annotations then phrases := loc :: !phrases (* comparison order: the intervals are sorted by order of increasing upper bound @@ -68,10 +64,9 @@ let cmp_loc_inner_first loc1 loc2 = match compare loc1.loc_end.pos_cnum loc2.loc_end.pos_cnum with | 0 -> compare loc2.loc_start.pos_cnum loc1.loc_start.pos_cnum | x -> x -;; + let cmp_ti_inner_first ti1 ti2 = cmp_loc_inner_first (get_location ti1) (get_location ti2) -;; let print_position pp pos = if pos = dummy_pos then @@ -86,13 +81,11 @@ let print_position pp pos = output_char pp ' '; output_int pp pos.pos_cnum; end -;; let print_location pp loc = print_position pp loc.loc_start; output_char pp ' '; - print_position pp loc.loc_end; -;; + print_position pp loc.loc_end let sort_filter_phrases () = let ph = List.sort (fun x y -> cmp_loc_inner_first y x) !phrases in @@ -105,8 +98,7 @@ let sort_filter_phrases () = then loop accu cur t else loop (loc :: accu) loc t in - phrases := loop [] Location.none ph; -;; + phrases := loop [] Location.none ph let rec printtyp_reset_maybe loc = match !phrases with @@ -115,14 +107,12 @@ let rec printtyp_reset_maybe loc = phrases := t; printtyp_reset_maybe loc; | _ -> () -;; let call_kind_string k = match k with | Tail -> "tail" | Stack -> "stack" | Inline -> "inline" -;; let print_ident_annot pp str k = match k with @@ -142,7 +132,6 @@ let print_ident_annot pp str k = output_string pp "ext_ref "; output_string pp str; output_char pp '\n' -;; (* The format of the annotation file is documented in emacs/caml-types.el. *) @@ -184,13 +173,11 @@ let print_info pp prev_loc ti = print_ident_annot pp str k; output_string pp ")\n"; loc -;; let get_info () = let info = List.fast_sort cmp_ti_inner_first !annotations in annotations := []; info -;; let dump filename = if !Clflags.annotations then begin @@ -206,5 +193,4 @@ let dump filename = phrases := []; end else begin annotations := []; - end; -;; + end diff --git a/src/ocaml/typing/stypes.mli b/src/ocaml/typing/stypes.mli index fda575fc02..3a86d27a57 100644 --- a/src/ocaml/typing/stypes.mli +++ b/src/ocaml/typing/stypes.mli @@ -17,7 +17,7 @@ (* Clflags.save_types must be true *) -open Typedtree;; +open Typedtree type annotation = | Ti_pat : 'k pattern_category * 'k general_pattern -> annotation @@ -26,11 +26,10 @@ type annotation = | Ti_mod of module_expr | An_call of Location.t * Annot.call | An_ident of Location.t * string * Annot.ident -;; -val record : annotation -> unit;; -val record_phrase : Location.t -> unit;; -val dump : string option -> unit;; +val record : annotation -> unit +val record_phrase : Location.t -> unit +val dump : string option -> unit -val get_location : annotation -> Location.t;; -val get_info : unit -> annotation list;; +val get_location : annotation -> Location.t +val get_info : unit -> annotation list diff --git a/src/ocaml/typing/subst.ml b/src/ocaml/typing/subst.ml index d77b73b592..de9bf07144 100644 --- a/src/ocaml/typing/subst.ml +++ b/src/ocaml/typing/subst.ml @@ -98,6 +98,8 @@ let rec module_path s path = Pdot(module_path s p, n) | Papply(p1, p2) -> Papply(module_path s p1, module_path s p2) + | Pextra_ty _ -> + fatal_error "Subst.module_path" let modtype_path s path = match Path.Map.find path s.modtypes with @@ -108,11 +110,18 @@ let modtype_path s path = match path with | Pdot(p, n) -> Pdot(module_path s p, n) - | Papply _ -> + | Papply _ | Pextra_ty _ -> fatal_error "Subst.modtype_path" | Pident _ -> path -let type_path s path = +(* For values, extension constructors, classes and class types *) +let value_path s path = + match path with + | Pident _ -> path + | Pdot(p, n) -> Pdot(module_path s p, n) + | Papply _ | Pextra_ty _ -> fatal_error "Subst.value_path" + +let rec type_path s path = match Path.Map.find path s.types with | Path p -> p | Type_function _ -> assert false @@ -123,13 +132,10 @@ let type_path s path = Pdot(module_path s p, n) | Papply _ -> fatal_error "Subst.type_path" - -let type_path s p = - match Path.constructor_typath p with - | Regular p -> type_path s p - | Cstr (ty_path, cstr) -> Pdot(type_path s ty_path, cstr) - | LocalExt _ -> type_path s p - | Ext (p, cstr) -> Pdot(module_path s p, cstr) + | Pextra_ty (p, extra) -> + match extra with + | Pcstr_ty _ -> Pextra_ty (type_path s p, extra) + | Pext_ty -> Pextra_ty (value_path s p, extra) let to_subst_by_type_function s p = match Path.Map.find p s.types with @@ -155,7 +161,68 @@ let norm = function | Tunivar None -> tunivar_none | d -> d -let ctype_apply_env_empty = ref (fun _ -> assert false) +let apply_type_function params args body = + For_copy.with_scope (fun copy_scope -> + List.iter2 + (fun param arg -> + For_copy.redirect_desc copy_scope param (Tsubst (arg, None))) + params args; + let rec copy ty = + assert (get_level ty = generic_level); + match get_desc ty with + | Tsubst (ty, _) -> ty + | Tvariant row -> + let t = newgenstub ~scope:(get_scope ty) in + For_copy.redirect_desc copy_scope ty (Tsubst (t, None)); + let more = row_more row in + assert (get_level more = generic_level); + let mored = get_desc more in + (* We must substitute in a subtle way *) + (* Tsubst takes a tuple containing the row var and the variant *) + let desc' = + match mored with + | Tsubst (_, Some ty2) -> + (* This variant type has been already copied *) + (* Change the stub to avoid Tlink in the new type *) + For_copy.redirect_desc copy_scope ty (Tsubst (ty2, None)); + Tlink ty2 + | _ -> + let more' = + match mored with + Tsubst (ty, None) -> ty + (* TODO: is this case possible? + possibly an interaction with (copy more) below? *) + | Tconstr _ | Tnil -> + copy more + | Tvar _ | Tunivar _ -> + newgenty mored + | _ -> assert false + in + let row = + match get_desc more' with (* PR#6163 *) + Tconstr (x,_,_) when not (is_fixed row) -> + let Row {fields; more; closed; name} = row_repr row in + create_row ~fields ~more ~closed ~name + ~fixed:(Some (Reified x)) + | _ -> row + in + (* Register new type first for recursion *) + For_copy.redirect_desc copy_scope more + (Tsubst(more', Some t)); + (* Return a new copy *) + Tvariant (copy_row copy true row false more') + in + Transient_expr.set_stub_desc t desc'; + t + | desc -> + let t = newgenstub ~scope:(get_scope ty) in + For_copy.redirect_desc copy_scope ty (Tsubst (t, None)); + let desc' = copy_type_desc copy desc in + Transient_expr.set_stub_desc t desc'; + t + in + copy body) + (* Similar to [Ctype.nondep_type_rec]. *) let rec typexp copy_scope s ty = @@ -204,7 +271,7 @@ let rec typexp copy_scope s ty = | exception Not_found -> Tconstr(type_path s p, args, ref Mnil) | Path _ -> Tconstr(type_path s p, args, ref Mnil) | Type_function { params; body } -> - Tlink (!ctype_apply_env_empty params body args) + Tlink (apply_type_function params args body) end | Tpackage(p, fl) -> Tpackage(modtype_path s p, @@ -308,7 +375,7 @@ let type_declaration' copy_scope s decl = type_arity = decl.type_arity; type_kind = begin match decl.type_kind with - Type_abstract -> Type_abstract + Type_abstract r -> Type_abstract r | Type_variant (cstrs, rep) -> Type_variant (List.map (constructor_declaration copy_scope s) cstrs, rep) @@ -384,6 +451,7 @@ let cltype_declaration' copy_scope s decl = clty_variance = decl.clty_variance; clty_type = class_type copy_scope s decl.clty_type; clty_path = type_path s decl.clty_path; + clty_hash_type = type_declaration' copy_scope s decl.clty_hash_type ; clty_loc = loc s decl.clty_loc; clty_attributes = attrs s decl.clty_attributes; clty_uid = decl.clty_uid; @@ -587,7 +655,7 @@ and subst_lazy_modtype scoping s = function | Pident _ -> MtyL_ident p | Pdot(p, n) -> MtyL_ident(Pdot(module_path s p, n)) - | Papply _ -> + | Papply _ | Pextra_ty _ -> fatal_error "Subst.modtype" end end diff --git a/src/ocaml/typing/subst.mli b/src/ocaml/typing/subst.mli index 3a1c85c871..d278d01c24 100644 --- a/src/ocaml/typing/subst.mli +++ b/src/ocaml/typing/subst.mli @@ -85,11 +85,6 @@ val module_declaration: scoping -> t -> module_declaration -> module_declaration apply (compose s1 s2) x = apply s2 (apply s1 x) *) val compose: t -> t -> t -(* A forward reference to be filled in ctype.ml. *) -val ctype_apply_env_empty: - (type_expr list -> type_expr -> type_expr list -> type_expr) ref - - module Lazy : sig type module_decl = { diff --git a/src/ocaml/typing/tast_iterator.ml b/src/ocaml/typing/tast_iterator.ml index 98bc77dfb5..6831fc1783 100644 --- a/src/ocaml/typing/tast_iterator.ml +++ b/src/ocaml/typing/tast_iterator.ml @@ -18,6 +18,8 @@ open Typedtree type iterator = { + attribute: iterator -> attribute -> unit; + attributes: iterator -> attributes -> unit; binding_op: iterator -> binding_op -> unit; case: 'k . iterator -> 'k case -> unit; class_declaration: iterator -> class_declaration -> unit; @@ -32,6 +34,7 @@ type iterator = env: iterator -> Env.t -> unit; expr: iterator -> expression -> unit; extension_constructor: iterator -> extension_constructor -> unit; + location: iterator -> Location.t -> unit; module_binding: iterator -> module_binding -> unit; module_coercion: iterator -> module_coercion -> unit; module_declaration: iterator -> module_declaration -> unit; @@ -59,35 +62,77 @@ type iterator = value_bindings: iterator -> (rec_flag * value_binding list) -> unit; value_description: iterator -> value_description -> unit; with_constraint: iterator -> with_constraint -> unit; + item_declaration: iterator -> item_declaration -> unit; } +let iter_snd f (_, y) = f y +let iter_loc sub {loc; _} = sub.location sub loc + +let location _sub _l = () + +let attribute sub x = + let iterator = { + Ast_iterator.default_iterator + with location = fun _this x -> sub.location sub x + } in + iter_loc sub x.Parsetree.attr_name; + iterator.payload iterator x.Parsetree.attr_payload; + sub.location sub x.Parsetree.attr_loc + +let attributes sub l = List.iter (attribute sub) l + let structure sub {str_items; str_final_env; _} = List.iter (sub.structure_item sub) str_items; sub.env sub str_final_env let class_infos sub f x = + sub.location sub x.ci_loc; + sub.attributes sub x.ci_attributes; + iter_loc sub x.ci_id_name; List.iter (fun (ct, _) -> sub.typ sub ct) x.ci_params; f x.ci_expr -let module_type_declaration sub {mtd_type; _} = - Option.iter (sub.module_type sub) mtd_type - -let module_declaration sub {md_type; _} = +let module_type_declaration sub x = + sub.item_declaration sub (Module_type x); + sub.location sub x.mtd_loc; + sub.attributes sub x.mtd_attributes; + iter_loc sub x.mtd_name; + Option.iter (sub.module_type sub) x.mtd_type + +let module_declaration sub md = + let {md_loc; md_name; md_type; md_attributes; _} = md in + sub.item_declaration sub (Module md); + sub.location sub md_loc; + sub.attributes sub md_attributes; + iter_loc sub md_name; sub.module_type sub md_type -let module_substitution _ _ = () -let include_infos f {incl_mod; _} = f incl_mod +let module_substitution sub ms = + let {ms_loc; ms_name; ms_txt; ms_attributes; _} = ms in + sub.item_declaration sub (Module_substitution ms); + sub.location sub ms_loc; + sub.attributes sub ms_attributes; + iter_loc sub ms_name; + iter_loc sub ms_txt + +let include_infos sub f {incl_loc; incl_mod; incl_attributes; _} = + sub.location sub incl_loc; + sub.attributes sub incl_attributes; + f incl_mod let class_type_declaration sub x = + sub.item_declaration sub (Class_type x); class_infos sub (sub.class_type sub) x let class_declaration sub x = + sub.item_declaration sub (Class x); class_infos sub (sub.class_expr sub) x -let structure_item sub {str_desc; str_env; _} = +let structure_item sub {str_loc; str_desc; str_env; _} = + sub.location sub str_loc; sub.env sub str_env; match str_desc with - | Tstr_eval (exp, _) -> sub.expr sub exp + | Tstr_eval (exp, attrs) -> sub.expr sub exp; sub.attributes sub attrs | Tstr_value (rec_flag, list) -> sub.value_bindings sub (rec_flag, list) | Tstr_primitive v -> sub.value_description sub v | Tstr_type (rec_flag, list) -> sub.type_declarations sub (rec_flag, list) @@ -99,22 +144,38 @@ let structure_item sub {str_desc; str_env; _} = | Tstr_class list -> List.iter (fun (cls,_) -> sub.class_declaration sub cls) list | Tstr_class_type list -> - List.iter (fun (_, _, cltd) -> sub.class_type_declaration sub cltd) list - | Tstr_include incl -> include_infos (sub.module_expr sub) incl + List.iter (fun (_, s, cltd) -> + iter_loc sub s; sub.class_type_declaration sub cltd) list + | Tstr_include incl -> include_infos sub (sub.module_expr sub) incl | Tstr_open od -> sub.open_declaration sub od - | Tstr_attribute _ -> () - -let value_description sub x = sub.typ sub x.val_desc - -let label_decl sub {ld_type; _} = sub.typ sub ld_type + | Tstr_attribute attr -> sub.attribute sub attr + +let value_description sub x = + sub.item_declaration sub (Value x); + sub.location sub x.val_loc; + sub.attributes sub x.val_attributes; + iter_loc sub x.val_name; + sub.typ sub x.val_desc + +let label_decl sub ({ld_loc; ld_name; ld_type; ld_attributes; _} as ld) = + sub.item_declaration sub (Label ld); + sub.location sub ld_loc; + sub.attributes sub ld_attributes; + iter_loc sub ld_name; + sub.typ sub ld_type let constructor_args sub = function | Cstr_tuple l -> List.iter (sub.typ sub) l | Cstr_record l -> List.iter (label_decl sub) l -let constructor_decl sub {cd_args; cd_res; _} = - constructor_args sub cd_args; - Option.iter (sub.typ sub) cd_res +let constructor_decl sub x = + sub.item_declaration sub (Constructor x); + sub.location sub x.cd_loc; + sub.attributes sub x.cd_attributes; + iter_loc sub x.cd_name; + List.iter (iter_loc sub) x.cd_vars; + constructor_args sub x.cd_args; + Option.iter (sub.typ sub) x.cd_res let type_kind sub = function | Ttype_abstract -> () @@ -122,55 +183,79 @@ let type_kind sub = function | Ttype_record list -> List.iter (label_decl sub) list | Ttype_open -> () -let type_declaration sub {typ_cstrs; typ_kind; typ_manifest; typ_params; _} = +let type_declaration sub x = + sub.item_declaration sub (Type x); + sub.location sub x.typ_loc; + sub.attributes sub x.typ_attributes; + iter_loc sub x.typ_name; List.iter - (fun (c1, c2, _) -> + (fun (c1, c2, loc) -> sub.typ sub c1; - sub.typ sub c2) - typ_cstrs; - sub.type_kind sub typ_kind; - Option.iter (sub.typ sub) typ_manifest; - List.iter (fun (c, _) -> sub.typ sub c) typ_params + sub.typ sub c2; + sub.location sub loc) + x.typ_cstrs; + sub.type_kind sub x.typ_kind; + Option.iter (sub.typ sub) x.typ_manifest; + List.iter (fun (c, _) -> sub.typ sub c) x.typ_params let type_declarations sub (_, list) = List.iter (sub.type_declaration sub) list -let type_extension sub {tyext_constructors; tyext_params; _} = - List.iter (fun (c, _) -> sub.typ sub c) tyext_params; - List.iter (sub.extension_constructor sub) tyext_constructors +let type_extension sub x = + sub.location sub x.tyext_loc; + sub.attributes sub x.tyext_attributes; + iter_loc sub x.tyext_txt; + List.iter (fun (c, _) -> sub.typ sub c) x.tyext_params; + List.iter (sub.extension_constructor sub) x.tyext_constructors -let type_exception sub {tyexn_constructor; _} = +let type_exception sub {tyexn_loc; tyexn_constructor; tyexn_attributes; _} = + sub.location sub tyexn_loc; + sub.attributes sub tyexn_attributes; sub.extension_constructor sub tyexn_constructor -let extension_constructor sub {ext_kind; _} = +let extension_constructor sub ec = + let {ext_loc; ext_name; ext_kind; ext_attributes; _} = ec in + sub.item_declaration sub (Extension_constructor ec); + sub.location sub ext_loc; + sub.attributes sub ext_attributes; + iter_loc sub ext_name; match ext_kind with - | Text_decl (_, ctl, cto) -> + | Text_decl (ids, ctl, cto) -> + List.iter (iter_loc sub) ids; constructor_args sub ctl; Option.iter (sub.typ sub) cto - | Text_rebind _ -> () + | Text_rebind (_, lid) -> iter_loc sub lid -let pat_extra sub (e, _loc, _attrs) = match e with - | Tpat_type _ -> () +let pat_extra sub (e, loc, attrs) = + sub.location sub loc; + sub.attributes sub attrs; + match e with + | Tpat_type (_, lid) -> iter_loc sub lid | Tpat_unpack -> () - | Tpat_open (_, _, env) -> sub.env sub env + | Tpat_open (_, lid, env) -> iter_loc sub lid; sub.env sub env | Tpat_constraint ct -> sub.typ sub ct let pat : type k . iterator -> k general_pattern -> unit - = fun sub {pat_extra = extra; pat_desc; pat_env; _} -> + = fun sub {pat_loc; pat_extra=extra; pat_desc; pat_env; pat_attributes; _} -> + sub.location sub pat_loc; + sub.attributes sub pat_attributes; sub.env sub pat_env; List.iter (pat_extra sub) extra; match pat_desc with | Tpat_any -> () - | Tpat_var _ -> () + | Tpat_var (_, s, _) -> iter_loc sub s | Tpat_constant _ -> () | Tpat_tuple l -> List.iter (sub.pat sub) l - | Tpat_construct (_, _, l, vto) -> + | Tpat_construct (lid, _, l, vto) -> + iter_loc sub lid; List.iter (sub.pat sub) l; - Option.iter (fun (_ids, ct) -> sub.typ sub ct) vto + Option.iter (fun (ids, ct) -> + List.iter (iter_loc sub) ids; sub.typ sub ct) vto | Tpat_variant (_, po, _) -> Option.iter (sub.pat sub) po - | Tpat_record (l, _) -> List.iter (fun (_, _, i) -> sub.pat sub i) l + | Tpat_record (l, _) -> + List.iter (fun (lid, _, i) -> iter_loc sub lid; sub.pat sub i) l | Tpat_array l -> List.iter (sub.pat sub) l - | Tpat_alias (p, _, _) -> sub.pat sub p + | Tpat_alias (p, _, s, _) -> sub.pat sub p; iter_loc sub s | Tpat_lazy p -> sub.pat sub p | Tpat_value p -> sub.pat sub (p :> pattern) | Tpat_exception p -> sub.pat sub p @@ -178,26 +263,49 @@ let pat sub.pat sub p1; sub.pat sub p2 -let expr sub {exp_extra; exp_desc; exp_env; _} = - let extra = function - | Texp_constraint cty -> sub.typ sub cty - | Texp_coerce (cty1, cty2) -> - Option.iter (sub.typ sub) cty1; - sub.typ sub cty2 - | Texp_newtype _ -> () - | Texp_newtype' _ -> () - | Texp_poly cto -> Option.iter (sub.typ sub) cto - in - List.iter (fun (e, _, _) -> extra e) exp_extra; +let extra sub = function + | Texp_constraint cty -> sub.typ sub cty + | Texp_coerce (cty1, cty2) -> + Option.iter (sub.typ sub) cty1; + sub.typ sub cty2 + | Texp_newtype _ | Texp_newtype' _ -> () + | Texp_poly cto -> Option.iter (sub.typ sub) cto + +let function_param sub fp = + sub.location sub fp.fp_loc; + match fp.fp_kind with + | Tparam_pat pat -> sub.pat sub pat + | Tparam_optional_default (pat, default_arg) -> + sub.pat sub pat; + sub.expr sub default_arg + +let function_body sub body = + match[@warning "+9"] body with + | Tfunction_body body -> + sub.expr sub body + | Tfunction_cases + { cases; loc; exp_extra; attributes; partial = _; param = _ } + -> + List.iter (sub.case sub) cases; + sub.location sub loc; + Option.iter (extra sub) exp_extra; + sub.attributes sub attributes + +let expr sub {exp_loc; exp_extra; exp_desc; exp_env; exp_attributes; _} = + let extra x = extra sub x in + sub.location sub exp_loc; + sub.attributes sub exp_attributes; + List.iter (fun (e, loc, _) -> extra e; sub.location sub loc) exp_extra; sub.env sub exp_env; match exp_desc with - | Texp_ident _ -> () + | Texp_ident (_, lid, _) -> iter_loc sub lid | Texp_constant _ -> () | Texp_let (rec_flag, list, exp) -> sub.value_bindings sub (rec_flag, list); sub.expr sub exp - | Texp_function {cases; _} -> - List.iter (sub.case sub) cases + | Texp_function (params, body) -> + List.iter (function_param sub) params; + function_body sub body | Texp_apply (exp, list) -> sub.expr sub exp; List.iter (fun (_, o) -> Option.iter (sub.expr sub) o) list @@ -208,16 +316,21 @@ let expr sub {exp_extra; exp_desc; exp_env; _} = sub.expr sub exp; List.iter (sub.case sub) cases | Texp_tuple list -> List.iter (sub.expr sub) list - | Texp_construct (_, _, args) -> List.iter (sub.expr sub) args + | Texp_construct (lid, _, args) -> + iter_loc sub lid; + List.iter (sub.expr sub) args | Texp_variant (_, expo) -> Option.iter (sub.expr sub) expo | Texp_record { fields; extended_expression; _} -> Array.iter (function | _, Kept _ -> () - | _, Overridden (_, exp) -> sub.expr sub exp) + | _, Overridden (lid, exp) -> iter_loc sub lid; sub.expr sub exp) fields; Option.iter (sub.expr sub) extended_expression; - | Texp_field (exp, _, _) -> sub.expr sub exp - | Texp_setfield (exp1, _, _, exp2) -> + | Texp_field (exp, lid, _) -> + iter_loc sub lid; + sub.expr sub exp + | Texp_setfield (exp1, lid, _, exp2) -> + iter_loc sub lid; sub.expr sub exp1; sub.expr sub exp2 | Texp_array list -> List.iter (sub.expr sub) list @@ -237,18 +350,21 @@ let expr sub {exp_extra; exp_desc; exp_env; _} = sub.expr sub exp3 | Texp_send (exp, _) -> sub.expr sub exp - | Texp_new _ -> () - | Texp_instvar _ -> () - | Texp_setinstvar (_, _, _, exp) ->sub.expr sub exp + | Texp_new (_, lid, _) -> iter_loc sub lid + | Texp_instvar (_, _, s) -> iter_loc sub s + | Texp_setinstvar (_, _, s, exp) -> + iter_loc sub s; + sub.expr sub exp | Texp_override (_, list) -> - List.iter (fun (_, _, e) -> sub.expr sub e) list - | Texp_letmodule (_, _, _, mexpr, exp) -> + List.iter (fun (_, s, e) -> iter_loc sub s; sub.expr sub e) list + | Texp_letmodule (_, s, _, mexpr, exp) -> + iter_loc sub s; sub.module_expr sub mexpr; sub.expr sub exp | Texp_letexception (cd, exp) -> sub.extension_constructor sub cd; sub.expr sub exp - | Texp_assert exp -> sub.expr sub exp + | Texp_assert (exp, _) -> sub.expr sub exp | Texp_lazy exp -> sub.expr sub exp | Texp_object (cl, _) -> sub.class_structure sub cl | Texp_pack mexpr -> sub.module_expr sub mexpr @@ -257,23 +373,28 @@ let expr sub {exp_extra; exp_desc; exp_env; _} = List.iter (sub.binding_op sub) ands; sub.case sub body | Texp_unreachable -> () - | Texp_extension_constructor _ -> () + | Texp_extension_constructor (lid, _) -> iter_loc sub lid | Texp_open (od, e) -> sub.open_declaration sub od; sub.expr sub e | Texp_hole -> () -let package_type sub {pack_fields; _} = - List.iter (fun (_, p) -> sub.typ sub p) pack_fields +let package_type sub {pack_fields; pack_txt; _} = + List.iter (fun (lid, p) -> iter_loc sub lid; sub.typ sub p) pack_fields; + iter_loc sub pack_txt -let binding_op sub {bop_exp; _} = sub.expr sub bop_exp +let binding_op sub {bop_loc; bop_op_name; bop_exp; _} = + sub.location sub bop_loc; + iter_loc sub bop_op_name; + sub.expr sub bop_exp let signature sub {sig_items; sig_final_env; _} = sub.env sub sig_final_env; List.iter (sub.signature_item sub) sig_items -let signature_item sub {sig_desc; sig_env; _} = +let signature_item sub {sig_loc; sig_desc; sig_env; _} = + sub.location sub sig_loc; sub.env sub sig_env; match sig_desc with | Tsig_value v -> sub.value_description sub v @@ -286,45 +407,55 @@ let signature_item sub {sig_desc; sig_env; _} = | Tsig_recmodule list -> List.iter (sub.module_declaration sub) list | Tsig_modtype x -> sub.module_type_declaration sub x | Tsig_modtypesubst x -> sub.module_type_declaration sub x - | Tsig_include incl -> include_infos (sub.module_type sub) incl + | Tsig_include incl -> include_infos sub (sub.module_type sub) incl | Tsig_class list -> List.iter (sub.class_description sub) list | Tsig_class_type list -> List.iter (sub.class_type_declaration sub) list | Tsig_open od -> sub.open_description sub od | Tsig_attribute _ -> () let class_description sub x = + sub.item_declaration sub (Class_type x); class_infos sub (sub.class_type sub) x let functor_parameter sub = function | Unit -> () - | Named (_, _, mtype) -> sub.module_type sub mtype + | Named (_, s, mtype) -> iter_loc sub s; sub.module_type sub mtype -let module_type sub {mty_desc; mty_env; _} = +let module_type sub {mty_loc; mty_desc; mty_env; mty_attributes; _} = + sub.location sub mty_loc; + sub.attributes sub mty_attributes; sub.env sub mty_env; match mty_desc with - | Tmty_ident _ -> () - | Tmty_alias _ -> () + | Tmty_ident (_, lid) -> iter_loc sub lid + | Tmty_alias (_, lid) -> iter_loc sub lid | Tmty_signature sg -> sub.signature sub sg | Tmty_functor (arg, mtype2) -> functor_parameter sub arg; sub.module_type sub mtype2 | Tmty_with (mtype, list) -> sub.module_type sub mtype; - List.iter (fun (_, _, e) -> sub.with_constraint sub e) list + List.iter (fun (_, lid, e) -> + iter_loc sub lid; sub.with_constraint sub e) list | Tmty_typeof mexpr -> sub.module_expr sub mexpr let with_constraint sub = function | Twith_type decl -> sub.type_declaration sub decl | Twith_typesubst decl -> sub.type_declaration sub decl - | Twith_module _ -> () - | Twith_modsubst _ -> () - | Twith_modtype _ -> () - | Twith_modtypesubst _ -> () + | Twith_module (_, lid) -> iter_loc sub lid + | Twith_modsubst (_, lid) -> iter_loc sub lid + | Twith_modtype mty -> sub.module_type sub mty + | Twith_modtypesubst mty -> sub.module_type sub mty -let open_description sub {open_env; _} = sub.env sub open_env +let open_description sub {open_loc; open_expr; open_env; open_attributes; _} = + sub.location sub open_loc; + sub.attributes sub open_attributes; + iter_snd (iter_loc sub) open_expr; + sub.env sub open_env -let open_declaration sub {open_expr; open_env; _} = +let open_declaration sub {open_loc; open_expr; open_env; open_attributes; _} = + sub.location sub open_loc; + sub.attributes sub open_attributes; sub.module_expr sub open_expr; sub.env sub open_env @@ -339,12 +470,17 @@ let module_coercion sub = function | Tcoerce_structure (l1, l2) -> List.iter (fun (_, c) -> sub.module_coercion sub c) l1; List.iter (fun (_, _ ,c) -> sub.module_coercion sub c) l2 - | Tcoerce_primitive {pc_env; _} -> sub.env sub pc_env + | Tcoerce_primitive {pc_loc; pc_env; _} -> + sub.location sub pc_loc; + sub.env sub pc_env -let module_expr sub {mod_desc; mod_env; _} = +let module_expr sub {mod_loc; mod_desc; mod_env; mod_attributes; _} = + sub.location sub mod_loc; + sub.attributes sub mod_attributes; sub.env sub mod_env; match mod_desc with - | Tmod_ident _ | Tmod_hole -> () + | Tmod_hole -> () + | Tmod_ident (_, lid) -> iter_loc sub lid | Tmod_structure st -> sub.structure sub st | Tmod_functor (arg, mexpr) -> functor_parameter sub arg; @@ -353,6 +489,8 @@ let module_expr sub {mod_desc; mod_env; _} = sub.module_expr sub mexp1; sub.module_expr sub mexp2; sub.module_coercion sub c + | Tmod_apply_unit mexp1 -> + sub.module_expr sub mexp1; | Tmod_constraint (mexpr, _, Tmodtype_implicit, c) -> sub.module_expr sub mexpr; sub.module_coercion sub c @@ -362,9 +500,16 @@ let module_expr sub {mod_desc; mod_env; _} = sub.module_coercion sub c | Tmod_unpack (exp, _) -> sub.expr sub exp -let module_binding sub {mb_expr; _} = sub.module_expr sub mb_expr +let module_binding sub ({mb_loc; mb_name; mb_expr; mb_attributes; _} as mb) = + sub.item_declaration sub (Module_binding mb); + sub.location sub mb_loc; + sub.attributes sub mb_attributes; + iter_loc sub mb_name; + sub.module_expr sub mb_expr -let class_expr sub {cl_desc; cl_env; _} = +let class_expr sub {cl_loc; cl_desc; cl_env; cl_attributes; _} = + sub.location sub cl_loc; + sub.attributes sub cl_attributes; sub.env sub cl_env; match cl_desc with | Tcl_constraint (cl, clty, _, _, _) -> @@ -382,16 +527,22 @@ let class_expr sub {cl_desc; cl_env; _} = sub.value_bindings sub (rec_flag, value_bindings); List.iter (fun (_, e) -> sub.expr sub e) ivars; sub.class_expr sub cl - | Tcl_ident (_, _, tyl) -> List.iter (sub.typ sub) tyl + | Tcl_ident (_, lid, tyl) -> + iter_loc sub lid; + List.iter (sub.typ sub) tyl | Tcl_open (od, e) -> sub.open_description sub od; sub.class_expr sub e -let class_type sub {cltyp_desc; cltyp_env; _} = +let class_type sub {cltyp_loc; cltyp_desc; cltyp_env; cltyp_attributes; _} = + sub.location sub cltyp_loc; + sub.attributes sub cltyp_attributes; sub.env sub cltyp_env; match cltyp_desc with | Tcty_signature csg -> sub.class_signature sub csg - | Tcty_constr (_, _, list) -> List.iter (sub.typ sub) list + | Tcty_constr (_, lid, list) -> + iter_loc sub lid; + List.iter (sub.typ sub) list | Tcty_arrow (_, ct, cl) -> sub.typ sub ct; sub.class_type sub cl @@ -403,7 +554,9 @@ let class_signature sub {csig_self; csig_fields; _} = sub.typ sub csig_self; List.iter (sub.class_type_field sub) csig_fields -let class_type_field sub {ctf_desc; _} = +let class_type_field sub {ctf_loc; ctf_desc; ctf_attributes; _} = + sub.location sub ctf_loc; + sub.attributes sub ctf_attributes; match ctf_desc with | Tctf_inherit ct -> sub.class_type sub ct | Tctf_val (_, _, _, ct) -> sub.typ sub ct @@ -411,9 +564,11 @@ let class_type_field sub {ctf_desc; _} = | Tctf_constraint (ct1, ct2) -> sub.typ sub ct1; sub.typ sub ct2 - | Tctf_attribute _ -> () + | Tctf_attribute attr -> sub.attribute sub attr -let typ sub {ctyp_desc; ctyp_env; _} = +let typ sub {ctyp_loc; ctyp_desc; ctyp_env; ctyp_attributes; _} = + sub.location sub ctyp_loc; + sub.attributes sub ctyp_attributes; sub.env sub ctyp_env; match ctyp_desc with | Ttyp_any -> () @@ -422,41 +577,55 @@ let typ sub {ctyp_desc; ctyp_env; _} = sub.typ sub ct1; sub.typ sub ct2 | Ttyp_tuple list -> List.iter (sub.typ sub) list - | Ttyp_constr (_, _, list) -> List.iter (sub.typ sub) list + | Ttyp_constr (_, lid, list) -> + iter_loc sub lid; + List.iter (sub.typ sub) list | Ttyp_object (list, _) -> List.iter (sub.object_field sub) list - | Ttyp_class (_, _, list) -> List.iter (sub.typ sub) list + | Ttyp_class (_, lid, list) -> + iter_loc sub lid; + List.iter (sub.typ sub) list | Ttyp_alias (ct, _) -> sub.typ sub ct | Ttyp_variant (list, _, _) -> List.iter (sub.row_field sub) list | Ttyp_poly (_, ct) -> sub.typ sub ct | Ttyp_package pack -> sub.package_type sub pack + | Ttyp_open (_, mod_ident, t) -> + iter_loc sub mod_ident; + sub.typ sub t let class_structure sub {cstr_self; cstr_fields; _} = sub.pat sub cstr_self; List.iter (sub.class_field sub) cstr_fields -let row_field sub {rf_desc; _} = +let row_field sub {rf_loc; rf_desc; rf_attributes; _} = + sub.location sub rf_loc; + sub.attributes sub rf_attributes; match rf_desc with - | Ttag (_, _, list) -> List.iter (sub.typ sub) list + | Ttag (s, _, list) -> iter_loc sub s; List.iter (sub.typ sub) list | Tinherit ct -> sub.typ sub ct -let object_field sub {of_desc; _} = +let object_field sub {of_loc; of_desc; of_attributes; _} = + sub.location sub of_loc; + sub.attributes sub of_attributes; match of_desc with - | OTtag (_, ct) -> sub.typ sub ct + | OTtag (s, ct) -> iter_loc sub s; sub.typ sub ct | OTinherit ct -> sub.typ sub ct let class_field_kind sub = function | Tcfk_virtual ct -> sub.typ sub ct | Tcfk_concrete (_, e) -> sub.expr sub e -let class_field sub {cf_desc; _} = match cf_desc with +let class_field sub {cf_loc; cf_desc; cf_attributes; _} = + sub.location sub cf_loc; + sub.attributes sub cf_attributes; + match cf_desc with | Tcf_inherit (_, cl, _, _, _) -> sub.class_expr sub cl | Tcf_constraint (cty1, cty2) -> sub.typ sub cty1; sub.typ sub cty2 - | Tcf_val (_, _, _, k, _) -> class_field_kind sub k - | Tcf_method (_, _, k) -> class_field_kind sub k + | Tcf_val (s, _, _, k, _) -> iter_loc sub s; class_field_kind sub k + | Tcf_method (s, _, k) -> iter_loc sub s;class_field_kind sub k | Tcf_initializer exp -> sub.expr sub exp - | Tcf_attribute _ -> () + | Tcf_attribute attr -> sub.attribute sub attr let value_bindings sub (_, list) = List.iter (sub.value_binding sub) list @@ -465,14 +634,21 @@ let case sub {c_lhs; c_guard; c_rhs} = Option.iter (sub.expr sub) c_guard; sub.expr sub c_rhs -let value_binding sub {vb_pat; vb_expr; _} = +let value_binding sub ({vb_loc; vb_pat; vb_expr; vb_attributes; _} as vb) = + sub.item_declaration sub (Value_binding vb); + sub.location sub vb_loc; + sub.attributes sub vb_attributes; sub.pat sub vb_pat; sub.expr sub vb_expr let env _sub _ = () +let item_declaration _sub _ = () + let default_iterator = { + attribute; + attributes; binding_op; case; class_declaration; @@ -487,6 +663,7 @@ let default_iterator = env; expr; extension_constructor; + location; module_binding; module_coercion; module_declaration; @@ -514,4 +691,5 @@ let default_iterator = value_bindings; value_description; with_constraint; + item_declaration; } diff --git a/src/ocaml/typing/tast_iterator.mli b/src/ocaml/typing/tast_iterator.mli index e126128edf..38cd4eac94 100644 --- a/src/ocaml/typing/tast_iterator.mli +++ b/src/ocaml/typing/tast_iterator.mli @@ -22,6 +22,8 @@ open Typedtree type iterator = { + attribute: iterator -> attribute -> unit; + attributes: iterator -> attributes -> unit; binding_op: iterator -> binding_op -> unit; case: 'k . iterator -> 'k case -> unit; class_declaration: iterator -> class_declaration -> unit; @@ -36,6 +38,7 @@ type iterator = env: iterator -> Env.t -> unit; expr: iterator -> expression -> unit; extension_constructor: iterator -> extension_constructor -> unit; + location: iterator -> Location.t -> unit; module_binding: iterator -> module_binding -> unit; module_coercion: iterator -> module_coercion -> unit; module_declaration: iterator -> module_declaration -> unit; @@ -63,6 +66,7 @@ type iterator = value_bindings: iterator -> (rec_flag * value_binding list) -> unit; value_description: iterator -> value_description -> unit; with_constraint: iterator -> with_constraint -> unit; + item_declaration: iterator -> item_declaration -> unit; } val default_iterator: iterator diff --git a/src/ocaml/typing/tast_mapper.ml b/src/ocaml/typing/tast_mapper.ml index fe7268676e..bcb0461741 100644 --- a/src/ocaml/typing/tast_mapper.ml +++ b/src/ocaml/typing/tast_mapper.ml @@ -16,11 +16,13 @@ open Asttypes open Typedtree -(* TODO: add 'methods' for location, attribute, extension, +(* TODO: add 'methods' for extension, include_declaration, include_description *) type mapper = { + attribute : mapper -> attribute -> attribute; + attributes : mapper -> attributes -> attributes; binding_op: mapper -> binding_op -> binding_op; case: 'k . mapper -> 'k case -> 'k case; class_declaration: mapper -> class_declaration -> class_declaration; @@ -37,6 +39,7 @@ type mapper = expr: mapper -> expression -> expression; extension_constructor: mapper -> extension_constructor -> extension_constructor; + location: mapper -> Location.t -> Location.t; module_binding: mapper -> module_binding -> module_binding; module_coercion: mapper -> module_coercion -> module_coercion; module_declaration: mapper -> module_declaration -> module_declaration; @@ -72,6 +75,22 @@ type mapper = let id x = x let tuple2 f1 f2 (x, y) = (f1 x, f2 y) let tuple3 f1 f2 f3 (x, y, z) = (f1 x, f2 y, f3 z) +let map_loc sub {loc; txt} = {loc=sub.location sub loc; txt} + +let location _sub l = l + +let attribute sub x = + let mapper = { + Ast_mapper.default_mapper + with location = fun _this x -> sub.location sub x + } in + Parsetree.{ + attr_name = map_loc sub x.attr_name; + attr_payload = mapper.payload mapper x.attr_payload; + attr_loc = sub.location sub x.attr_loc + } + +let attributes sub l = List.map (attribute sub) l let structure sub {str_items; str_type; str_final_env} = { @@ -82,21 +101,38 @@ let structure sub {str_items; str_type; str_final_env} = let class_infos sub f x = {x with + ci_loc = sub.location sub x.ci_loc; + ci_id_name = map_loc sub x.ci_id_name; ci_params = List.map (tuple2 (sub.typ sub) id) x.ci_params; ci_expr = f x.ci_expr; + ci_attributes = sub.attributes sub x.ci_attributes; } let module_type_declaration sub x = + let mtd_loc = sub.location sub x.mtd_loc in + let mtd_name = map_loc sub x.mtd_name in let mtd_type = Option.map (sub.module_type sub) x.mtd_type in - {x with mtd_type} + let mtd_attributes = sub.attributes sub x.mtd_attributes in + {x with mtd_loc; mtd_name; mtd_type; mtd_attributes} let module_declaration sub x = + let md_loc = sub.location sub x.md_loc in + let md_name = map_loc sub x.md_name in let md_type = sub.module_type sub x.md_type in - {x with md_type} + let md_attributes = sub.attributes sub x.md_attributes in + {x with md_loc; md_name; md_type; md_attributes} -let module_substitution _ x = x +let module_substitution sub x = + let ms_loc = sub.location sub x.ms_loc in + let ms_name = map_loc sub x.ms_name in + let ms_txt = map_loc sub x.ms_txt in + let ms_attributes = sub.attributes sub x.ms_attributes in + {x with ms_loc; ms_name; ms_txt; ms_attributes} -let include_infos f x = {x with incl_mod = f x.incl_mod} +let include_infos sub f x = + let incl_loc = sub.location sub x.incl_loc in + let incl_attributes = sub.attributes sub x.incl_attributes in + {x with incl_loc; incl_attributes; incl_mod = f x.incl_mod} let class_type_declaration sub x = class_infos sub (sub.class_type sub) x @@ -104,11 +140,13 @@ let class_type_declaration sub x = let class_declaration sub x = class_infos sub (sub.class_expr sub) x -let structure_item sub {str_desc; str_loc; str_env} = +let structure_item sub {str_loc; str_desc; str_env} = + let str_loc = sub.location sub str_loc in let str_env = sub.env sub str_env in let str_desc = match str_desc with - | Tstr_eval (exp, attrs) -> Tstr_eval (sub.expr sub exp, attrs) + | Tstr_eval (exp, attrs) -> + Tstr_eval (sub.expr sub exp, sub.attributes sub attrs) | Tstr_value (rec_flag, list) -> let (rec_flag, list) = sub.value_bindings sub (rec_flag, list) in Tstr_value (rec_flag, list) @@ -127,30 +165,41 @@ let structure_item sub {str_desc; str_loc; str_env} = (List.map (tuple2 (sub.class_declaration sub) id) list) | Tstr_class_type list -> Tstr_class_type - (List.map (tuple3 id id (sub.class_type_declaration sub)) list) + (List.map (tuple3 + id (map_loc sub) (sub.class_type_declaration sub)) list) | Tstr_include incl -> - Tstr_include (include_infos (sub.module_expr sub) incl) + Tstr_include (include_infos sub (sub.module_expr sub) incl) | Tstr_open od -> Tstr_open (sub.open_declaration sub od) - | Tstr_attribute _ as d -> d + | Tstr_attribute attr -> Tstr_attribute (sub.attribute sub attr) in {str_desc; str_env; str_loc} let value_description sub x = + let val_loc = sub.location sub x.val_loc in + let val_name = map_loc sub x.val_name in let val_desc = sub.typ sub x.val_desc in - {x with val_desc} + let val_attributes = sub.attributes sub x.val_attributes in + {x with val_loc; val_name; val_desc; val_attributes} let label_decl sub x = + let ld_loc = sub.location sub x.ld_loc in + let ld_name = map_loc sub x.ld_name in let ld_type = sub.typ sub x.ld_type in - {x with ld_type} + let ld_attributes = sub.attributes sub x.ld_attributes in + {x with ld_loc; ld_name; ld_type; ld_attributes} let constructor_args sub = function | Cstr_tuple l -> Cstr_tuple (List.map (sub.typ sub) l) | Cstr_record l -> Cstr_record (List.map (label_decl sub) l) let constructor_decl sub cd = + let cd_loc = sub.location sub cd.cd_loc in + let cd_name = map_loc sub cd.cd_name in + let cd_vars = List.map (map_loc sub) cd.cd_vars in let cd_args = constructor_args sub cd.cd_args in let cd_res = Option.map (sub.typ sub) cd.cd_res in - {cd with cd_args; cd_res} + let cd_attributes = sub.attributes sub cd.cd_attributes in + {cd with cd_loc; cd_name; cd_vars; cd_args; cd_res; cd_attributes} let type_kind sub = function | Ttype_abstract -> Ttype_abstract @@ -159,67 +208,90 @@ let type_kind sub = function | Ttype_open -> Ttype_open let type_declaration sub x = + let typ_loc = sub.location sub x.typ_loc in + let typ_name = map_loc sub x.typ_name in let typ_cstrs = List.map - (tuple3 (sub.typ sub) (sub.typ sub) id) + (tuple3 (sub.typ sub) (sub.typ sub) (sub.location sub)) x.typ_cstrs in let typ_kind = sub.type_kind sub x.typ_kind in let typ_manifest = Option.map (sub.typ sub) x.typ_manifest in let typ_params = List.map (tuple2 (sub.typ sub) id) x.typ_params in - {x with typ_cstrs; typ_kind; typ_manifest; typ_params} + let typ_attributes = sub.attributes sub x.typ_attributes in + {x with typ_loc; typ_name; typ_cstrs; typ_kind; typ_manifest; typ_params; + typ_attributes} let type_declarations sub (rec_flag, list) = (rec_flag, List.map (sub.type_declaration sub) list) let type_extension sub x = + let tyext_loc = sub.location sub x.tyext_loc in + let tyext_txt = map_loc sub x.tyext_txt in let tyext_params = List.map (tuple2 (sub.typ sub) id) x.tyext_params in let tyext_constructors = List.map (sub.extension_constructor sub) x.tyext_constructors in - {x with tyext_constructors; tyext_params} + let tyext_attributes = sub.attributes sub x.tyext_attributes in + {x with tyext_loc; tyext_txt; tyext_constructors; tyext_params; + tyext_attributes} let type_exception sub x = + let tyexn_loc = sub.location sub x.tyexn_loc in let tyexn_constructor = sub.extension_constructor sub x.tyexn_constructor in - {x with tyexn_constructor} + let tyexn_attributes = sub.attributes sub x.tyexn_attributes in + {tyexn_loc; tyexn_constructor; tyexn_attributes} let extension_constructor sub x = + let ext_loc = sub.location sub x.ext_loc in + let ext_name = map_loc sub x.ext_name in let ext_kind = match x.ext_kind with - Text_decl(v, ctl, cto) -> - Text_decl(v, constructor_args sub ctl, Option.map (sub.typ sub) cto) - | Text_rebind _ as d -> d + Text_decl(ids, ctl, cto) -> + Text_decl( + List.map (map_loc sub) ids, + constructor_args sub ctl, + Option.map (sub.typ sub) cto + ) + | Text_rebind (path, lid) -> + Text_rebind (path, map_loc sub lid) in - {x with ext_kind} + let ext_attributes = sub.attributes sub x.ext_attributes in + {x with ext_loc; ext_name; ext_kind; ext_attributes} let pat_extra sub = function - | Tpat_type _ | Tpat_unpack as d -> d - | Tpat_open (path,loc,env) -> Tpat_open (path, loc, sub.env sub env) + | Tpat_type (path,loc) -> Tpat_type (path, map_loc sub loc) + | Tpat_open (path,loc,env) -> + Tpat_open (path, map_loc sub loc, sub.env sub env) | Tpat_constraint ct -> Tpat_constraint (sub.typ sub ct) let pat : type k . mapper -> k general_pattern -> k general_pattern = fun sub x -> + let pat_loc = sub.location sub x.pat_loc in let pat_env = sub.env sub x.pat_env in - let pat_extra = List.map (tuple3 (pat_extra sub) id id) x.pat_extra in + let pat_extra = + List.map (tuple3 (pat_extra sub) id (sub.attributes sub)) x.pat_extra in let pat_desc : k pattern_desc = match x.pat_desc with | Tpat_any - | Tpat_var _ | Tpat_constant _ -> x.pat_desc + | Tpat_var (id, s, uid) -> Tpat_var (id, map_loc sub s, uid) | Tpat_tuple l -> Tpat_tuple (List.map (sub.pat sub) l) | Tpat_construct (loc, cd, l, vto) -> - let vto = Option.map (fun (vl,cty) -> vl, sub.typ sub cty) vto in - Tpat_construct (loc, cd, List.map (sub.pat sub) l, vto) + let vto = Option.map (fun (vl,cty) -> + List.map (map_loc sub) vl, sub.typ sub cty) vto in + Tpat_construct (map_loc sub loc, cd, List.map (sub.pat sub) l, vto) | Tpat_variant (l, po, rd) -> Tpat_variant (l, Option.map (sub.pat sub) po, rd) | Tpat_record (l, closed) -> - Tpat_record (List.map (tuple3 id id (sub.pat sub)) l, closed) + Tpat_record (List.map (tuple3 (map_loc sub) id (sub.pat sub)) l, closed) | Tpat_array l -> Tpat_array (List.map (sub.pat sub) l) - | Tpat_alias (p, id, s) -> Tpat_alias (sub.pat sub p, id, s) + | Tpat_alias (p, id, s, uid) -> + Tpat_alias (sub.pat sub p, id, map_loc sub s, uid) | Tpat_lazy p -> Tpat_lazy (sub.pat sub p) | Tpat_value p -> (as_computation_pattern (sub.pat sub (p :> pattern))).pat_desc @@ -228,30 +300,63 @@ let pat | Tpat_or (p1, p2, rd) -> Tpat_or (sub.pat sub p1, sub.pat sub p2, rd) in - {x with pat_extra; pat_desc; pat_env} + let pat_attributes = sub.attributes sub x.pat_attributes in + {x with pat_loc; pat_extra; pat_desc; pat_env; pat_attributes} + +let function_param sub fp = + let fp_kind = + match fp.fp_kind with + | Tparam_pat pat -> Tparam_pat (sub.pat sub pat) + | Tparam_optional_default (pat, expr) -> + let pat = sub.pat sub pat in + let expr = sub.expr sub expr in + Tparam_optional_default (pat, expr) + in + let fp_loc = sub.location sub fp.fp_loc in + { fp_kind; + fp_param = fp.fp_param; + fp_arg_label = fp.fp_arg_label; + fp_partial = fp.fp_partial; + fp_newtypes = fp.fp_newtypes; + fp_loc; + } + +let extra sub = function + | Texp_constraint cty -> + Texp_constraint (sub.typ sub cty) + | Texp_coerce (cty1, cty2) -> + Texp_coerce (Option.map (sub.typ sub) cty1, sub.typ sub cty2) + | (Texp_newtype _ | Texp_newtype' _) as d -> d + | Texp_poly cto -> Texp_poly (Option.map (sub.typ sub) cto) + +let function_body sub body = + match body with + | Tfunction_body body -> + Tfunction_body (sub.expr sub body) + | Tfunction_cases { cases; partial; param; loc; exp_extra; attributes } -> + let loc = sub.location sub loc in + let cases = List.map (sub.case sub) cases in + let exp_extra = Option.map (extra sub) exp_extra in + let attributes = sub.attributes sub attributes in + Tfunction_cases { cases; partial; param; loc; exp_extra; attributes } let expr sub x = - let extra = function - | Texp_constraint cty -> - Texp_constraint (sub.typ sub cty) - | Texp_coerce (cty1, cty2) -> - Texp_coerce (Option.map (sub.typ sub) cty1, sub.typ sub cty2) - | Texp_newtype _ as d -> d - | Texp_newtype' _ as d -> d - | Texp_poly cto -> Texp_poly (Option.map (sub.typ sub) cto) - in - let exp_extra = List.map (tuple3 extra id id) x.exp_extra in + let extra x = extra sub x in + let exp_loc = sub.location sub x.exp_loc in + let exp_extra = List.map (tuple3 extra (sub.location sub) id) x.exp_extra in let exp_env = sub.env sub x.exp_env in let exp_desc = match x.exp_desc with - | Texp_ident _ + | Texp_ident (path, lid, vd) -> + Texp_ident (path, map_loc sub lid, vd) | Texp_constant _ as d -> d | Texp_let (rec_flag, list, exp) -> let (rec_flag, list) = sub.value_bindings sub (rec_flag, list) in Texp_let (rec_flag, list, sub.expr sub exp) - | Texp_function { arg_label; param; cases; partial; } -> - let cases = List.map (sub.case sub) cases in - Texp_function { arg_label; param; cases; partial; } + | Texp_function (params, body) -> + let params = List.map (function_param sub) params in + let body = function_body sub body in + Texp_function (params, body) | Texp_apply (exp, list) -> Texp_apply ( sub.expr sub exp, @@ -271,14 +376,14 @@ let expr sub x = | Texp_tuple list -> Texp_tuple (List.map (sub.expr sub) list) | Texp_construct (lid, cd, args) -> - Texp_construct (lid, cd, List.map (sub.expr sub) args) + Texp_construct (map_loc sub lid, cd, List.map (sub.expr sub) args) | Texp_variant (l, expo) -> Texp_variant (l, Option.map (sub.expr sub) expo) | Texp_record { fields; representation; extended_expression } -> let fields = Array.map (function - | label, Kept t -> label, Kept t + | label, Kept (t, mut) -> label, Kept (t, mut) | label, Overridden (lid, exp) -> - label, Overridden (lid, sub.expr sub exp)) + label, Overridden (map_loc sub lid, sub.expr sub exp)) fields in Texp_record { @@ -286,11 +391,11 @@ let expr sub x = extended_expression = Option.map (sub.expr sub) extended_expression; } | Texp_field (exp, lid, ld) -> - Texp_field (sub.expr sub exp, lid, ld) + Texp_field (sub.expr sub exp, map_loc sub lid, ld) | Texp_setfield (exp1, lid, ld, exp2) -> Texp_setfield ( sub.expr sub exp1, - lid, + map_loc sub lid, ld, sub.expr sub exp2 ) @@ -327,24 +432,34 @@ let expr sub x = sub.expr sub exp, meth ) - | Texp_new _ - | Texp_instvar _ as d -> d + | Texp_new (path, lid, cd) -> + Texp_new ( + path, + map_loc sub lid, + cd + ) + | Texp_instvar (path1, path2, id) -> + Texp_instvar ( + path1, + path2, + map_loc sub id + ) | Texp_setinstvar (path1, path2, id, exp) -> Texp_setinstvar ( path1, path2, - id, + map_loc sub id, sub.expr sub exp ) | Texp_override (path, list) -> Texp_override ( path, - List.map (tuple3 id id (sub.expr sub)) list + List.map (tuple3 id (map_loc sub) (sub.expr sub)) list ) | Texp_letmodule (id, s, pres, mexpr, exp) -> Texp_letmodule ( id, - s, + map_loc sub s, pres, sub.module_expr sub mexpr, sub.expr sub exp @@ -354,8 +469,8 @@ let expr sub x = sub.extension_constructor sub cd, sub.expr sub exp ) - | Texp_assert exp -> - Texp_assert (sub.expr sub exp) + | Texp_assert (exp, loc) -> + Texp_assert (sub.expr sub exp, loc) | Texp_lazy exp -> Texp_lazy (sub.expr sub exp) | Texp_object (cl, sl) -> @@ -372,22 +487,27 @@ let expr sub x = } | Texp_unreachable -> Texp_unreachable - | Texp_extension_constructor _ as e -> - e + | Texp_extension_constructor (lid, path) -> + Texp_extension_constructor (map_loc sub lid, path) | Texp_open (od, e) -> Texp_open (sub.open_declaration sub od, sub.expr sub e) | Texp_hole -> Texp_hole in - {x with exp_extra; exp_desc; exp_env} + let exp_attributes = sub.attributes sub x.exp_attributes in + {x with exp_loc; exp_extra; exp_desc; exp_env; exp_attributes} let package_type sub x = - let pack_fields = List.map (tuple2 id (sub.typ sub)) x.pack_fields in - {x with pack_fields} + let pack_txt = map_loc sub x.pack_txt in + let pack_fields = List.map + (tuple2 (map_loc sub) (sub.typ sub)) x.pack_fields in + {x with pack_txt; pack_fields} let binding_op sub x = - { x with bop_exp = sub.expr sub x.bop_exp } + let bop_loc = sub.location sub x.bop_loc in + let bop_op_name = map_loc sub x.bop_op_name in + { x with bop_loc; bop_op_name; bop_exp = sub.expr sub x.bop_exp } let signature sub x = let sig_final_env = sub.env sub x.sig_final_env in @@ -395,6 +515,7 @@ let signature sub x = {x with sig_items; sig_final_env} let signature_item sub x = + let sig_loc = sub.location sub x.sig_loc in let sig_env = sub.env sub x.sig_env in let sig_desc = match x.sig_desc with @@ -421,57 +542,64 @@ let signature_item sub x = | Tsig_modtypesubst x -> Tsig_modtypesubst (sub.module_type_declaration sub x) | Tsig_include incl -> - Tsig_include (include_infos (sub.module_type sub) incl) + Tsig_include (include_infos sub (sub.module_type sub) incl) | Tsig_class list -> Tsig_class (List.map (sub.class_description sub) list) | Tsig_class_type list -> Tsig_class_type (List.map (sub.class_type_declaration sub) list) | Tsig_open od -> Tsig_open (sub.open_description sub od) - | Tsig_attribute _ as d -> d + | Tsig_attribute attr -> Tsig_attribute (sub.attribute sub attr) in - {x with sig_desc; sig_env} + {sig_loc; sig_desc; sig_env} let class_description sub x = class_infos sub (sub.class_type sub) x let functor_parameter sub = function | Unit -> Unit - | Named (id, s, mtype) -> Named (id, s, sub.module_type sub mtype) + | Named (id, s, mtype) -> Named (id, map_loc sub s, sub.module_type sub mtype) let module_type sub x = + let mty_loc = sub.location sub x.mty_loc in let mty_env = sub.env sub x.mty_env in let mty_desc = match x.mty_desc with - | Tmty_ident _ - | Tmty_alias _ as d -> d + | Tmty_ident (path, lid) -> Tmty_ident (path, map_loc sub lid) + | Tmty_alias (path, lid) -> Tmty_alias (path, map_loc sub lid) | Tmty_signature sg -> Tmty_signature (sub.signature sub sg) | Tmty_functor (arg, mtype2) -> Tmty_functor (functor_parameter sub arg, sub.module_type sub mtype2) | Tmty_with (mtype, list) -> Tmty_with ( sub.module_type sub mtype, - List.map (tuple3 id id (sub.with_constraint sub)) list + List.map (tuple3 id (map_loc sub) (sub.with_constraint sub)) list ) | Tmty_typeof mexpr -> Tmty_typeof (sub.module_expr sub mexpr) in - {x with mty_desc; mty_env} + let mty_attributes = sub.attributes sub x.mty_attributes in + {x with mty_loc; mty_desc; mty_env; mty_attributes} let with_constraint sub = function | Twith_type decl -> Twith_type (sub.type_declaration sub decl) | Twith_typesubst decl -> Twith_typesubst (sub.type_declaration sub decl) | Twith_modtype mty -> Twith_modtype (sub.module_type sub mty) | Twith_modtypesubst mty -> Twith_modtypesubst (sub.module_type sub mty) - | Twith_module _ - | Twith_modsubst _ as d -> d + | Twith_module (path, lid) -> Twith_module (path, map_loc sub lid) + | Twith_modsubst (path, lid) -> Twith_modsubst (path, map_loc sub lid) let open_description sub od = - {od with open_env = sub.env sub od.open_env} + {od with open_loc = sub.location sub od.open_loc; + open_expr = tuple2 id (map_loc sub) od.open_expr; + open_env = sub.env sub od.open_env; + open_attributes = sub.attributes sub od.open_attributes} let open_declaration sub od = - {od with open_expr = sub.module_expr sub od.open_expr; - open_env = sub.env sub od.open_env} + {od with open_loc = sub.location sub od.open_loc; + open_expr = sub.module_expr sub od.open_expr; + open_env = sub.env sub od.open_env; + open_attributes = sub.attributes sub od.open_attributes} let module_coercion sub = function | Tcoerce_none -> Tcoerce_none @@ -486,13 +614,15 @@ let module_coercion sub = function in Tcoerce_structure (l1', l2') | Tcoerce_primitive pc -> - Tcoerce_primitive {pc with pc_env = sub.env sub pc.pc_env} + Tcoerce_primitive {pc with pc_loc = sub.location sub pc.pc_loc; + pc_env = sub.env sub pc.pc_env} let module_expr sub x = + let mod_loc = sub.location sub x.mod_loc in let mod_env = sub.env sub x.mod_env in let mod_desc = match x.mod_desc with - | Tmod_ident _ as d -> d + | Tmod_ident (path, lid) -> Tmod_ident (path, map_loc sub lid) | Tmod_hole -> Tmod_hole | Tmod_structure st -> Tmod_structure (sub.structure sub st) | Tmod_functor (arg, mexpr) -> @@ -503,6 +633,8 @@ let module_expr sub x = sub.module_expr sub mexp2, sub.module_coercion sub c ) + | Tmod_apply_unit mexp1 -> + Tmod_apply_unit (sub.module_expr sub mexp1) | Tmod_constraint (mexpr, mt, Tmodtype_implicit, c) -> Tmod_constraint (sub.module_expr sub mexpr, mt, Tmodtype_implicit, sub.module_coercion sub c) @@ -520,13 +652,18 @@ let module_expr sub x = mty ) in - {x with mod_desc; mod_env} + let mod_attributes = sub.attributes sub x.mod_attributes in + {x with mod_loc; mod_desc; mod_env; mod_attributes} let module_binding sub x = + let mb_loc = sub.location sub x.mb_loc in + let mb_name = map_loc sub x.mb_name in let mb_expr = sub.module_expr sub x.mb_expr in - {x with mb_expr} + let mb_attributes = sub.attributes sub x.mb_attributes in + {x with mb_loc; mb_name; mb_expr; mb_attributes} let class_expr sub x = + let cl_loc = sub.location sub x.cl_loc in let cl_env = sub.env sub x.cl_env in let cl_desc = match x.cl_desc with @@ -564,13 +701,15 @@ let class_expr sub x = sub.class_expr sub cl ) | Tcl_ident (path, lid, tyl) -> - Tcl_ident (path, lid, List.map (sub.typ sub) tyl) + Tcl_ident (path, map_loc sub lid, List.map (sub.typ sub) tyl) | Tcl_open (od, e) -> Tcl_open (sub.open_description sub od, sub.class_expr sub e) in - {x with cl_desc; cl_env} + let cl_attributes = sub.attributes sub x.cl_attributes in + {x with cl_loc; cl_desc; cl_env; cl_attributes} let class_type sub x = + let cltyp_loc = sub.location sub x.cltyp_loc in let cltyp_env = sub.env sub x.cltyp_env in let cltyp_desc = match x.cltyp_desc with @@ -578,7 +717,7 @@ let class_type sub x = | Tcty_constr (path, lid, list) -> Tcty_constr ( path, - lid, + map_loc sub lid, List.map (sub.typ sub) list ) | Tcty_arrow (label, ct, cl) -> @@ -590,7 +729,8 @@ let class_type sub x = | Tcty_open (od, e) -> Tcty_open (sub.open_description sub od, sub.class_type sub e) in - {x with cltyp_desc; cltyp_env} + let cltyp_attributes = sub.attributes sub x.cltyp_attributes in + {x with cltyp_loc; cltyp_desc; cltyp_env; cltyp_attributes} let class_signature sub x = let csig_self = sub.typ sub x.csig_self in @@ -598,6 +738,7 @@ let class_signature sub x = {x with csig_self; csig_fields} let class_type_field sub x = + let ctf_loc = sub.location sub x.ctf_loc in let ctf_desc = match x.ctf_desc with | Tctf_inherit ct -> @@ -608,11 +749,14 @@ let class_type_field sub x = Tctf_method (s, priv, virt, sub.typ sub ct) | Tctf_constraint (ct1, ct2) -> Tctf_constraint (sub.typ sub ct1, sub.typ sub ct2) - | Tctf_attribute _ as d -> d + | Tctf_attribute attr -> + Tctf_attribute (sub.attribute sub attr) in - {x with ctf_desc} + let ctf_attributes = sub.attributes sub x.ctf_attributes in + {ctf_loc; ctf_desc; ctf_attributes} let typ sub x = + let ctyp_loc = sub.location sub x.ctyp_loc in let ctyp_env = sub.env sub x.ctyp_env in let ctyp_desc = match x.ctyp_desc with @@ -622,13 +766,13 @@ let typ sub x = Ttyp_arrow (label, sub.typ sub ct1, sub.typ sub ct2) | Ttyp_tuple list -> Ttyp_tuple (List.map (sub.typ sub) list) | Ttyp_constr (path, lid, list) -> - Ttyp_constr (path, lid, List.map (sub.typ sub) list) + Ttyp_constr (path, map_loc sub lid, List.map (sub.typ sub) list) | Ttyp_object (list, closed) -> Ttyp_object ((List.map (sub.object_field sub) list), closed) | Ttyp_class (path, lid, list) -> Ttyp_class (path, - lid, + map_loc sub lid, List.map (sub.typ sub) list ) | Ttyp_alias (ct, s) -> @@ -639,8 +783,11 @@ let typ sub x = Ttyp_poly (sl, sub.typ sub ct) | Ttyp_package pack -> Ttyp_package (sub.package_type sub pack) + | Ttyp_open (path, mod_ident, t) -> + Ttyp_open (path, map_loc sub mod_ident, sub.typ sub t) in - {x with ctyp_desc; ctyp_env} + let ctyp_attributes = sub.attributes sub x.ctyp_attributes in + {x with ctyp_loc; ctyp_desc; ctyp_env; ctyp_attributes} let class_structure sub x = let cstr_self = sub.pat sub x.cstr_self in @@ -648,26 +795,31 @@ let class_structure sub x = {x with cstr_self; cstr_fields} let row_field sub x = + let rf_loc = sub.location sub x.rf_loc in let rf_desc = match x.rf_desc with | Ttag (label, b, list) -> - Ttag (label, b, List.map (sub.typ sub) list) + Ttag (map_loc sub label, b, List.map (sub.typ sub) list) | Tinherit ct -> Tinherit (sub.typ sub ct) in - { x with rf_desc; } + let rf_attributes = sub.attributes sub x.rf_attributes in + {rf_loc; rf_desc; rf_attributes} let object_field sub x = + let of_loc = sub.location sub x.of_loc in let of_desc = match x.of_desc with | OTtag (label, ct) -> - OTtag (label, (sub.typ sub ct)) + OTtag (map_loc sub label, (sub.typ sub ct)) | OTinherit ct -> OTinherit (sub.typ sub ct) in - { x with of_desc; } + let of_attributes = sub.attributes sub x.of_attributes in + {of_loc; of_desc; of_attributes} let class_field_kind sub = function | Tcfk_virtual ct -> Tcfk_virtual (sub.typ sub ct) | Tcfk_concrete (ovf, e) -> Tcfk_concrete (ovf, sub.expr sub e) let class_field sub x = + let cf_loc = sub.location sub x.cf_loc in let cf_desc = match x.cf_desc with | Tcf_inherit (ovf, cl, super, vals, meths) -> @@ -678,14 +830,16 @@ let class_field sub x = sub.typ sub cty' ) | Tcf_val (s, mf, id, k, b) -> - Tcf_val (s, mf, id, class_field_kind sub k, b) + Tcf_val (map_loc sub s, mf, id, class_field_kind sub k, b) | Tcf_method (s, priv, k) -> - Tcf_method (s, priv, class_field_kind sub k) + Tcf_method (map_loc sub s, priv, class_field_kind sub k) | Tcf_initializer exp -> Tcf_initializer (sub.expr sub exp) - | Tcf_attribute _ as d -> d + | Tcf_attribute attr -> + Tcf_attribute (sub.attribute sub attr) in - {x with cf_desc} + let cf_attributes = sub.attributes sub x.cf_attributes in + {cf_loc; cf_desc; cf_attributes} let value_bindings sub (rec_flag, list) = (rec_flag, List.map (sub.value_binding sub) list) @@ -700,14 +854,19 @@ let case } let value_binding sub x = + let vb_loc = sub.location sub x.vb_loc in let vb_pat = sub.pat sub x.vb_pat in let vb_expr = sub.expr sub x.vb_expr in - {x with vb_pat; vb_expr} + let vb_attributes = sub.attributes sub x.vb_attributes in + let vb_rec_kind = x.vb_rec_kind in + {vb_loc; vb_pat; vb_expr; vb_attributes; vb_rec_kind} let env _sub x = x let default = { + attribute; + attributes; binding_op; case; class_declaration; @@ -722,6 +881,7 @@ let default = env; expr; extension_constructor; + location; module_binding; module_coercion; module_declaration; diff --git a/src/ocaml/typing/tast_mapper.mli b/src/ocaml/typing/tast_mapper.mli index ea6543d04f..f54cef2b06 100644 --- a/src/ocaml/typing/tast_mapper.mli +++ b/src/ocaml/typing/tast_mapper.mli @@ -20,6 +20,8 @@ open Typedtree type mapper = { + attribute : mapper -> attribute -> attribute; + attributes : mapper -> attributes -> attributes; binding_op: mapper -> binding_op -> binding_op; case: 'k . mapper -> 'k case -> 'k case; class_declaration: mapper -> class_declaration -> class_declaration; @@ -36,6 +38,7 @@ type mapper = expr: mapper -> expression -> expression; extension_constructor: mapper -> extension_constructor -> extension_constructor; + location: mapper -> Location.t -> Location.t; module_binding: mapper -> module_binding -> module_binding; module_coercion: mapper -> module_coercion -> module_coercion; module_declaration: mapper -> module_declaration -> module_declaration; diff --git a/src/ocaml/typing/typeclass.ml b/src/ocaml/typing/typeclass.ml index 28f0645780..0c14185f47 100644 --- a/src/ocaml/typing/typeclass.ml +++ b/src/ocaml/typing/typeclass.ml @@ -21,6 +21,7 @@ open Typecore open Typetexp open Format + type 'a class_info = { cls_id : Ident.t; cls_id_loc : string loc; @@ -29,7 +30,6 @@ type 'a class_info = { cls_ty_decl : class_type_declaration; cls_obj_id : Ident.t; cls_obj_abbr : type_declaration; - cls_typesharp_id : Ident.t; cls_abbr : type_declaration; cls_arity : int; cls_pub_methods : string list; @@ -42,7 +42,6 @@ type class_type_info = { clsty_ty_decl : class_type_declaration; clsty_obj_id : Ident.t; clsty_obj_abbr : type_declaration; - clsty_typesharp_id : Ident.t; clsty_abbr : type_declaration; clsty_info : Typedtree.class_type_declaration; } @@ -55,8 +54,6 @@ type 'a full_class = { cltydef: class_type_declaration; obj_id: Ident.t; obj_abbr: type_declaration; - cl_id: Ident.t; - cl_abbr: type_declaration; arity: int; pub_meths: string list; coe: Warnings.loc list; @@ -93,12 +90,16 @@ type error = | Undeclared_methods of kind * string list | Parameter_arity_mismatch of Longident.t * int * int | Parameter_mismatch of Errortrace.unification_error - | Bad_parameters of Ident.t * type_expr * type_expr + | Bad_parameters of Ident.t * type_expr list * type_expr list + | Bad_class_type_parameters of Ident.t * type_expr list * type_expr list | Class_match_failure of Ctype.class_match_failure list | Unbound_val of string - | Unbound_type_var of - (formatter -> unit) * (type_expr * bool * string * type_expr) - | Non_generalizable_class of Ident.t * Types.class_declaration + | Unbound_type_var of (formatter -> unit) * Ctype.closed_class_failure + | Non_generalizable_class of + { id : Ident.t + ; clty : Types.class_declaration + ; nongen_vars : type_expr list + } | Cannot_coerce_self of type_expr | Non_collapsable_conjunction of Ident.t * Types.class_declaration * Errortrace.unification_error @@ -255,9 +256,9 @@ let unify_delayed_method_type loc env label ty expected_ty= raise(Error(loc, env, Field_type_mismatch ("method", label, trace))) let type_constraint val_env sty sty' loc = - let cty = transl_simple_type val_env false sty in + let cty = transl_simple_type val_env ~closed:false sty in let ty = cty.ctyp_type in - let cty' = transl_simple_type val_env false sty' in + let cty' = transl_simple_type val_env ~closed:false sty' in let ty' = cty'.ctyp_type in begin try Ctype.unify val_env ty ty' with Ctype.Unify err -> @@ -268,9 +269,15 @@ let type_constraint val_env sty sty' loc = let make_method loc cl_num expr = let open Ast_helper in let mkid s = mkloc s loc in - Exp.fun_ ~loc:expr.pexp_loc Nolabel None - (Pat.alias ~loc (Pat.var ~loc (mkid "self-*")) (mkid ("self-" ^ cl_num))) - expr + let pat = + Pat.alias ~loc (Pat.var ~loc (mkid "self-*")) (mkid ("self-" ^ cl_num)) + in + Exp.function_ ~loc:expr.pexp_loc + [ { pparam_desc = Pparam_val (Nolabel, None, pat); + pparam_loc = pat.ppat_loc; + } + ] + None (Pfunction_body expr) (*******************************) @@ -297,7 +304,7 @@ let rec class_type_field env sign self_scope ctf = | Pctf_val ({txt=lab}, mut, virt, sty) -> mkctf_with_attrs (fun () -> - let cty = transl_simple_type env false sty in + let cty = transl_simple_type env ~closed:false sty in let ty = cty.ctyp_type in add_instance_variable ~strict:false loc env lab mut virt ty sign; Tctf_val (lab, mut, virt, cty)) @@ -321,7 +328,7 @@ let rec class_type_field env sign self_scope ctf = ) :: !delayed_meth_specs; Tctf_method (lab, priv, virt, returned_cty) | _ -> - let cty = transl_simple_type env false sty in + let cty = transl_simple_type env ~closed:false sty in let ty = cty.ctyp_type in add_method loc env lab priv virt ty sign; Tctf_method (lab, priv, virt, cty)) @@ -345,7 +352,7 @@ and class_signature virt env pcsig self_scope loc = (* Introduce a dummy method preventing self type from being closed. *) Ctype.add_dummy_method env ~scope:self_scope sign; - let self_cty = transl_simple_type env false sty in + let self_cty = transl_simple_type env ~closed:false sty in let self_type = self_cty.ctyp_type in begin try Ctype.unify env self_type sign.csig_self @@ -395,7 +402,7 @@ and class_type_aux env virt self_scope scty = List.length styl))); let ctys = List.map2 (fun sty ty -> - let cty' = transl_simple_type env false sty in + let cty' = transl_simple_type env ~closed:false sty in let ty' = cty'.ctyp_type in begin try Ctype.unify env ty' ty with Ctype.Unify err -> @@ -415,7 +422,7 @@ and class_type_aux env virt self_scope scty = cltyp (Tcty_signature clsig) typ | Pcty_arrow (l, sty, scty) -> - let cty = transl_simple_type env false sty in + let cty = transl_simple_type env ~closed:false sty in let ty = cty.ctyp_type in let ty = if Btype.is_optional l @@ -646,15 +653,14 @@ let rec class_field_first_pass self_loc cl_num sign self_scope acc cf = | Pcf_val (label, mut, Cfk_virtual styp) -> with_attrs (fun () -> - if !Clflags.principal then Ctype.begin_def (); - let cty = Typetexp.transl_simple_type val_env false styp in - let ty = cty.ctyp_type in - if !Clflags.principal then begin - Ctype.end_def (); - Ctype.generalize_structure ty - end; + let cty = + Ctype.with_local_level_if_principal + (fun () -> Typetexp.transl_simple_type val_env + ~closed:false styp) + ~post:(fun cty -> Ctype.generalize_structure cty.ctyp_type) + in add_instance_variable ~strict:true loc val_env - label.txt mut Virtual ty sign; + label.txt mut Virtual cty.ctyp_type sign; let already_declared, val_env, par_env, id, vars = match Vars.find label.txt vars with | id -> true, val_env, par_env, id, vars @@ -687,12 +693,11 @@ let rec class_field_first_pass self_loc cl_num sign self_scope acc cf = raise(Error(loc, val_env, No_overriding ("instance variable", label.txt))) end; - if !Clflags.principal then Ctype.begin_def (); - let definition = type_exp val_env sdefinition in - if !Clflags.principal then begin - Ctype.end_def (); - Ctype.generalize_structure definition.exp_type - end; + let definition = + Ctype.with_local_level_if_principal + ~post:Typecore.generalize_structure_exp + (fun () -> type_exp val_env sdefinition) + in add_instance_variable ~strict:true loc val_env label.txt mut Concrete definition.exp_type sign; let already_declared, val_env, par_env, id, vars = @@ -721,7 +726,7 @@ let rec class_field_first_pass self_loc cl_num sign self_scope acc cf = with_attrs (fun () -> let sty = Ast_helper.Typ.force_poly sty in - let cty = transl_simple_type val_env false sty in + let cty = transl_simple_type val_env ~closed:false sty in let ty = cty.ctyp_type in add_method loc val_env label.txt priv Virtual ty sign; let field = @@ -761,7 +766,7 @@ let rec class_field_first_pass self_loc cl_num sign self_scope acc cf = | Some sty -> let sty = Ast_helper.Typ.force_poly sty in let cty' = - Typetexp.transl_simple_type val_env false sty + Typetexp.transl_simple_type val_env ~closed:false sty in cty'.ctyp_type in @@ -774,7 +779,7 @@ let rec class_field_first_pass self_loc cl_num sign self_scope acc cf = Ctype.unify val_env (Ctype.newty (Tpoly (ty', []))) ty; Ctype.unify val_env (type_approx val_env sbody) ty' | Tpoly (ty1, tl) -> - let _, ty1' = Ctype.instance_poly false tl ty1 in + let _, ty1' = Ctype.instance_poly ~fixed:false tl ty1 in let ty2 = type_approx val_env sbody in Ctype.unify val_env ty2 ty1' | _ -> assert false @@ -910,9 +915,9 @@ and class_field_second_pass cl_num sign met_env field = mk_expected (Btype.newgenty (Tarrow(Nolabel, self_type, ty, commu_ok))) in - Ctype.raise_nongen_level (); - let texp = type_expect met_env sdefinition meth_type in - Ctype.end_def (); + let texp = + Ctype.with_raised_nongen_level + (fun () -> type_expect met_env sdefinition meth_type) in let kind = Tcfk_concrete (override, texp) in let desc = Tcf_method(label, priv, kind) in met_env, mkcf desc loc attributes) @@ -922,15 +927,15 @@ and class_field_second_pass cl_num sign met_env field = | Initializer { sexpr; warning_state; loc; attributes } -> Warnings.with_state warning_state (fun () -> - Ctype.raise_nongen_level (); let unit_type = Ctype.instance Predef.type_unit in let self_type = sign.Types.csig_self in let meth_type = mk_expected (Ctype.newty (Tarrow (Nolabel, self_type, unit_type, commu_ok))) in - let texp = type_expect met_env sexpr meth_type in - Ctype.end_def (); + let texp = + Ctype.with_raised_nongen_level + (fun () -> type_expect met_env sexpr meth_type) in let desc = Tcf_initializer texp in met_env, mkcf desc loc attributes) | Attribute { attribute; loc; attributes; } -> @@ -1065,7 +1070,7 @@ and class_expr_aux cl_num val_env met_env virt self_scope scl = if Path.same decl.cty_path unbound_class then raise(Error(scl.pcl_loc, val_env, Unbound_class_2 lid.txt)); let tyl = List.map - (fun sty -> transl_simple_type val_env false sty) + (fun sty -> transl_simple_type val_env ~closed:false sty) styl in let (params, clty) = @@ -1145,15 +1150,15 @@ and class_expr_aux cl_num val_env met_env virt self_scope scl = in class_expr cl_num val_env met_env virt self_scope sfun | Pcl_fun (l, None, spat, scl') -> - if !Clflags.principal then Ctype.begin_def (); let (pat, pv, val_env', met_env) = - Typecore.type_class_arg_pattern cl_num val_env met_env l spat + Ctype.with_local_level_if_principal + (fun () -> + Typecore.type_class_arg_pattern cl_num val_env met_env l spat) + ~post: begin fun (pat, _, _, _) -> + let gen {pat_type = ty} = Ctype.generalize_structure ty in + iter_pattern gen pat + end in - if !Clflags.principal then begin - Ctype.end_def (); - let gen {pat_type = ty} = Ctype.generalize_structure ty in - iter_pattern gen pat - end; let pv = List.map begin fun (id, id', _ty) -> @@ -1180,9 +1185,9 @@ and class_expr_aux cl_num val_env met_env virt self_scope scl = Typecore.check_partial val_env pat.pat_type pat.pat_loc [{c_lhs = pat; c_guard = None; c_rhs = dummy}] in - Ctype.raise_nongen_level (); - let cl = class_expr cl_num val_env' met_env virt self_scope scl' in - Ctype.end_def (); + let cl = + Ctype.with_raised_nongen_level + (fun () -> class_expr cl_num val_env' met_env virt self_scope scl') in if Btype.is_optional l && not_nolabel_function cl.cl_type then Location.prerr_warning pat.pat_loc Warnings.Unerasable_optional_argument; @@ -1195,12 +1200,11 @@ and class_expr_aux cl_num val_env met_env virt self_scope scl = } | Pcl_apply (scl', sargs) -> assert (sargs <> []); - if !Clflags.principal then Ctype.begin_def (); - let cl = class_expr cl_num val_env met_env virt self_scope scl' in - if !Clflags.principal then begin - Ctype.end_def (); - Ctype.generalize_class_type_structure cl.cl_type; - end; + let cl = + Ctype.with_local_level_if_principal + (fun () -> class_expr cl_num val_env met_env virt self_scope scl') + ~post:(fun cl -> Ctype.generalize_class_type_structure cl.cl_type) + in let rec nonopt_labels ls ty_fun = match ty_fun with | Cty_arrow (l, _, ty_res) -> @@ -1305,25 +1309,26 @@ and class_expr_aux cl_num val_env met_env virt self_scope scl = Typecore.type_let In_class_def val_env rec_flag sdefs in let (vals, met_env) = List.fold_right - (fun (id, _id_loc, _typ) (vals, met_env) -> + (fun (id, _id_loc, _typ, _uid) (vals, met_env) -> let path = Pident id in (* do not mark the value as used *) let vd = Env.find_value path val_env in - Ctype.begin_def (); + let ty = + Ctype.with_local_level ~post:Ctype.generalize + (fun () -> Ctype.instance vd.val_type) + in let expr = {exp_desc = Texp_ident(path, mknoloc(Longident.Lident (Ident.name id)),vd); exp_loc = Location.none; exp_extra = []; - exp_type = Ctype.instance vd.val_type; + exp_type = ty; exp_attributes = []; exp_env = val_env; } in - Ctype.end_def (); - Ctype.generalize expr.exp_type; let desc = - {val_type = expr.exp_type; val_kind = Val_ivar (Immutable, - cl_num); + {val_type = expr.exp_type; + val_kind = Val_ivar (Immutable, cl_num); val_attributes = []; Types.val_loc = vd.Types.val_loc; val_uid = vd.val_uid; @@ -1337,8 +1342,9 @@ and class_expr_aux cl_num val_env met_env virt self_scope scl = ([], met_env) in let cl = class_expr cl_num val_env met_env virt self_scope scl' in - let () = if rec_flag = Recursive then - check_recursive_bindings val_env defs + let defs = match rec_flag with + | Recursive -> annotate_recursive_bindings val_env defs + | Nonrecursive -> defs in rc {cl_desc = Tcl_let (rec_flag, defs, vals, cl); cl_loc = scl.pcl_loc; @@ -1347,22 +1353,29 @@ and class_expr_aux cl_num val_env met_env virt self_scope scl = cl_attributes = scl.pcl_attributes; } | Pcl_constraint (scl', scty) -> - Ctype.begin_class_def (); - let context = Typetexp.narrow () in - let cl = class_expr cl_num val_env met_env virt self_scope scl' in - complete_class_type cl.cl_loc val_env virt Class_type cl.cl_type; - Typetexp.widen context; - let context = Typetexp.narrow () in - let clty = class_type val_env virt self_scope scty in - complete_class_type clty.cltyp_loc val_env virt Class clty.cltyp_type; - Typetexp.widen context; - Ctype.end_def (); - - Ctype.limited_generalize_class_type - (Btype.self_type_row cl.cl_type) cl.cl_type; - Ctype.limited_generalize_class_type - (Btype.self_type_row clty.cltyp_type) clty.cltyp_type; - + let cl, clty = + Ctype.with_local_level_for_class begin fun () -> + let cl = + Typetexp.TyVarEnv.with_local_scope begin fun () -> + let cl = class_expr cl_num val_env met_env virt self_scope scl' in + complete_class_type cl.cl_loc val_env virt Class_type cl.cl_type; + cl + end + and clty = + Typetexp.TyVarEnv.with_local_scope begin fun () -> + let clty = class_type val_env virt self_scope scty in + complete_class_type + clty.cltyp_loc val_env virt Class clty.cltyp_type; + clty + end + in + cl, clty + end + ~post: begin fun ({cl_type=cl}, {cltyp_type=clty}) -> + Ctype.limited_generalize_class_type (Btype.self_type_row cl) cl; + Ctype.limited_generalize_class_type (Btype.self_type_row clty) clty; + end + in begin match Includeclass.class_types val_env cl.cl_type clty.cltyp_type with @@ -1426,17 +1439,16 @@ let rec approx_description ct = (*******************************) -let temp_abbrev loc env id arity uid = +let temp_abbrev loc arity uid = let params = ref [] in for _i = 1 to arity do params := Ctype.newvar () :: !params done; let ty = Ctype.newobj (Ctype.newvar ()) in - let env = - Env.add_type ~check:true id + let ty_td = {type_params = !params; type_arity = arity; - type_kind = Type_abstract; + type_kind = Type_abstract Definition; type_private = Public; type_manifest = Some ty; type_variance = Variance.unknown_signature ~injective:false ~arity; @@ -1449,24 +1461,22 @@ let temp_abbrev loc env id arity uid = type_unboxed_default = false; type_uid = uid; } - env in - (!params, ty, env) + (!params, ty, ty_td) let initial_env define_class approx - (res, env) (cl, id, ty_id, obj_id, cl_id, uid) = + (res, env) (cl, id, ty_id, obj_id, uid) = (* Temporary abbreviations *) let arity = List.length cl.pci_params in - let (obj_params, obj_ty, env) = temp_abbrev cl.pci_loc env obj_id arity uid in - let (cl_params, cl_ty, env) = temp_abbrev cl.pci_loc env cl_id arity uid in + let (obj_params, obj_ty, obj_td) = temp_abbrev cl.pci_loc arity uid in + let env = Env.add_type ~check:true obj_id obj_td env in + let (cl_params, cl_ty, cl_td) = temp_abbrev cl.pci_loc arity uid in (* Temporary type for the class constructor *) - if !Clflags.principal then Ctype.begin_def (); - let constr_type = approx cl.pci_expr in - if !Clflags.principal then begin - Ctype.end_def (); - Ctype.generalize_structure constr_type; - end; + let constr_type = + Ctype.with_local_level_if_principal (fun () -> approx cl.pci_expr) + ~post:Ctype.generalize_structure + in let dummy_cty = Cty_signature (Ctype.new_class_signature ()) in let dummy_class = {Types.cty_params = []; (* Dummy value *) @@ -1489,6 +1499,7 @@ let initial_env define_class approx clty_variance = []; clty_type = dummy_cty; (* Dummy value *) clty_path = unbound_class; + clty_hash_type = cl_td; (* Dummy value *) clty_loc = Location.none; clty_attributes = []; clty_uid = uid; @@ -1502,54 +1513,57 @@ let initial_env define_class approx in ((cl, id, ty_id, obj_id, obj_params, obj_ty, - cl_id, cl_params, cl_ty, - constr_type, dummy_class)::res, + cl_params, cl_ty, cl_td, + constr_type, + dummy_class)::res, env) let class_infos define_class kind (cl, id, ty_id, obj_id, obj_params, obj_ty, - cl_id, cl_params, cl_ty, - constr_type, dummy_class) + cl_params, cl_ty, cl_td, + constr_type, + dummy_class) (res, env) = - reset_type_variables (); - Ctype.begin_class_def (); - - (* Introduce class parameters *) - let ci_params = - let make_param (sty, v) = - try - (transl_type_param env sty, v) - with Already_bound -> - raise(Error(sty.ptyp_loc, env, Repeated_parameter)) - in - List.map make_param cl.pci_params - in - let params = List.map (fun (cty, _) -> cty.ctyp_type) ci_params in - - (* Allow self coercions (only for class declarations) *) - let coercion_locs = ref [] in - - (* Type the class expression *) - let (expr, typ) = - try - Typecore.self_coercion := - (Path.Pident obj_id, coercion_locs) :: !Typecore.self_coercion; - let res = kind env cl.pci_virt cl.pci_expr in - Typecore.self_coercion := List.tl !Typecore.self_coercion; - res - with exn -> - Typecore.self_coercion := []; raise exn + let ci_params, params, coercion_locs, expr, typ, sign = + Ctype.with_local_level_for_class begin fun () -> + TyVarEnv.reset (); + (* Introduce class parameters *) + let ci_params = + let make_param (sty, v) = + try + (transl_type_param env sty, v) + with Already_bound -> + raise(Error(sty.ptyp_loc, env, Repeated_parameter)) + in + List.map make_param cl.pci_params + in + let params = List.map (fun (cty, _) -> cty.ctyp_type) ci_params in + + (* Allow self coercions (only for class declarations) *) + let coercion_locs = ref [] in + + (* Type the class expression *) + let (expr, typ) = + try + Typecore.self_coercion := + (Path.Pident obj_id, coercion_locs) :: !Typecore.self_coercion; + let res = kind env cl.pci_virt cl.pci_expr in + Typecore.self_coercion := List.tl !Typecore.self_coercion; + res + with exn -> + Typecore.self_coercion := []; raise exn + in + let sign = Btype.signature_of_class_type typ in + (ci_params, params, coercion_locs, expr, typ, sign) + end + ~post: begin fun (_, params, _, _, typ, sign) -> + (* Generalize the row variable *) + List.iter (Ctype.limited_generalize sign.csig_self_row) params; + Ctype.limited_generalize_class_type sign.csig_self_row typ; + end in - let sign = Btype.signature_of_class_type typ in - - Ctype.end_def (); - - (* Generalize the row variable *) - List.iter (Ctype.limited_generalize sign.csig_self_row) params; - Ctype.limited_generalize_class_type sign.csig_self_row typ; - (* Check the abbreviation for the object type *) let (obj_params', obj_type) = Ctype.instance_class params typ in let constr = Ctype.newconstr (Path.Pident obj_id) obj_params in @@ -1560,9 +1574,7 @@ let class_infos define_class kind List.iter2 (Ctype.unify env) obj_params obj_params' with Ctype.Unify _ -> raise(Error(cl.pci_loc, env, - Bad_parameters (obj_id, constr, - Ctype.newconstr (Path.Pident obj_id) - obj_params'))) + Bad_parameters (obj_id, obj_params, obj_params'))) end; let ty = Btype.self_type obj_type in begin try @@ -1583,17 +1595,13 @@ let class_infos define_class kind List.iter2 (Ctype.unify env) cl_params cl_params' with Ctype.Unify _ -> raise(Error(cl.pci_loc, env, - Bad_parameters (cl_id, - Ctype.newconstr (Path.Pident cl_id) - cl_params, - Ctype.newconstr (Path.Pident cl_id) - cl_params'))) + Bad_class_type_parameters (ty_id, cl_params, cl_params'))) end; begin try Ctype.unify env ty cl_ty with Ctype.Unify _ -> - let constr = Ctype.newconstr (Path.Pident cl_id) params in - raise(Error(cl.pci_loc, env, Abbrev_type_clash (constr, ty, cl_ty))) + let ty_expanded = Ctype.object_fields ty in + raise(Error(cl.pci_loc, env, Abbrev_type_clash (ty, ty_expanded, cl_ty))) end end; @@ -1614,6 +1622,7 @@ let class_infos define_class kind {clty_params = params; clty_type = Btype.class_body typ; clty_variance = cty_variance; clty_path = Path.Pident obj_id; + clty_hash_type = cl_td; clty_loc = cl.pci_loc; clty_attributes = cl.pci_attributes; clty_uid = dummy_class.cty_uid; @@ -1644,15 +1653,7 @@ let class_infos define_class kind (* Final definitions *) let (params', typ') = Ctype.instance_class params typ in - let cltydef = - {clty_params = params'; clty_type = Btype.class_body typ'; - clty_variance = cty_variance; - clty_path = Path.Pident obj_id; - clty_loc = cl.pci_loc; - clty_attributes = cl.pci_attributes; - clty_uid = dummy_class.cty_uid; - } - and clty = + let clty = {cty_params = params'; cty_type = typ'; cty_variance = cty_variance; cty_path = Path.Pident obj_id; @@ -1671,7 +1672,7 @@ let class_infos define_class kind { type_params = obj_params; type_arity = arity; - type_kind = Type_abstract; + type_kind = Type_abstract Definition; type_private = Public; type_manifest = Some obj_ty; type_variance = Variance.unknown_signature ~injective:false ~arity; @@ -1690,31 +1691,29 @@ let class_infos define_class kind in Ctype.set_object_name obj_id cl_params cl_ty; let cl_abbr = - let arity = List.length cl_params in - { + { cl_td with type_params = cl_params; - type_arity = arity; - type_kind = Type_abstract; - type_private = Public; - type_manifest = Some cl_ty; - type_variance = Variance.unknown_signature ~injective:false ~arity; - type_separability = Types.Separability.default_signature ~arity; - type_is_newtype = false; - type_expansion_scope = Btype.lowest_level; - type_loc = cl.pci_loc; - type_attributes = []; (* or keep attrs from cl? *) - type_immediate = Unknown; - type_unboxed_default = false; - type_uid = dummy_class.cty_uid; + type_manifest = Some cl_ty + } + in + let cltydef = + {clty_params = params'; clty_type = Btype.class_body typ'; + clty_variance = cty_variance; + clty_path = Path.Pident obj_id; + clty_hash_type = cl_abbr; + clty_loc = cl.pci_loc; + clty_attributes = cl.pci_attributes; + clty_uid = dummy_class.cty_uid; } in - ((cl, id, clty, ty_id, cltydef, obj_id, obj_abbr, cl_id, cl_abbr, ci_params, + ((cl, id, clty, ty_id, cltydef, obj_id, obj_abbr, ci_params, arity, pub_meths, List.rev !coercion_locs, expr) :: res, env) let final_decl env define_class - (cl, id, clty, ty_id, cltydef, obj_id, obj_abbr, cl_id, cl_abbr, ci_params, + (cl, id, clty, ty_id, cltydef, obj_id, obj_abbr, ci_params, arity, pub_meths, coe, expr) = + let cl_abbr = cltydef.clty_hash_type in begin try Ctype.collapse_conj_params env clty.cty_params with Ctype.Unify err -> @@ -1729,8 +1728,12 @@ let final_decl env define_class List.iter Ctype.generalize cl_abbr.type_params; Option.iter Ctype.generalize cl_abbr.type_manifest; - if Ctype.nongen_class_declaration clty then - raise(Error(cl.pci_loc, env, Non_generalizable_class (id, clty))); + Ctype.nongen_vars_in_class_declaration clty + |> Option.iter (fun vars -> + let nongen_vars = Btype.TypeSet.elements vars in + raise(Error(cl.pci_loc, env + , Non_generalizable_class { id; clty; nongen_vars })); + ); begin match Ctype.closed_class clty.cty_params @@ -1745,7 +1748,7 @@ let final_decl env define_class in raise(Error(cl.pci_loc, env, Unbound_type_var(printer, reason))) end; - { id; clty; ty_id; cltydef; obj_id; obj_abbr; cl_id; cl_abbr; arity; + { id; clty; ty_id; cltydef; obj_id; obj_abbr; arity; pub_meths; coe; id_loc = cl.pci_name; req = { ci_loc = cl.pci_loc; @@ -1756,7 +1759,6 @@ let final_decl env define_class ci_id_class = id; ci_id_class_type = ty_id; ci_id_object = obj_id; - ci_id_typehash = cl_id; ci_expr = expr; ci_decl = clty; ci_type_decl = cltydef; @@ -1768,40 +1770,40 @@ let final_decl env define_class let class_infos define_class kind (cl, id, ty_id, obj_id, obj_params, obj_ty, - cl_id, cl_params, cl_ty, - constr_type, dummy_class) + cl_params, cl_ty, cl_td, + constr_type, + dummy_class) (res, env) = Builtin_attributes.warning_scope cl.pci_attributes (fun () -> class_infos define_class kind (cl, id, ty_id, obj_id, obj_params, obj_ty, - cl_id, cl_params, cl_ty, - constr_type, dummy_class) + cl_params, cl_ty, cl_td, + constr_type, + dummy_class) (res, env) ) -let extract_type_decls { clty; cltydef; obj_id; obj_abbr; cl_abbr; req} decls = - (obj_id, obj_abbr, cl_abbr, clty, cltydef, req) :: decls +let extract_type_decls { clty; cltydef; obj_id; obj_abbr; req} decls = + (obj_id, obj_abbr, clty, cltydef, req) :: decls -let merge_type_decls decl (obj_abbr, cl_abbr, clty, cltydef) = - {decl with obj_abbr; cl_abbr; clty; cltydef} +let merge_type_decls decl (obj_abbr, clty, cltydef) = + {decl with obj_abbr; clty; cltydef} -let final_env define_class env { id; clty; ty_id; cltydef; obj_id; obj_abbr; - cl_id; cl_abbr } = +let final_env define_class env { id; clty; ty_id; cltydef; obj_id; obj_abbr; } = (* Add definitions after cleaning them *) Env.add_type ~check:true obj_id (Subst.type_declaration Subst.identity obj_abbr) ( - Env.add_type ~check:true cl_id - (Subst.type_declaration Subst.identity cl_abbr) ( Env.add_cltype ty_id (Subst.cltype_declaration Subst.identity cltydef) ( if define_class then Env.add_class id (Subst.class_declaration Subst.identity clty) env - else env))) + else env)) (* Check that #c is coercible to c if there is a self-coercion *) let check_coercions env { id; id_loc; clty; ty_id; cltydef; obj_id; obj_abbr; - cl_id; cl_abbr; arity; pub_meths; coe; req } = + arity; pub_meths; coe; req } = + let cl_abbr = cltydef.clty_hash_type in begin match coe with [] -> () | loc :: _ -> let cl_ty, obj_ty = @@ -1830,7 +1832,6 @@ let check_coercions env { id; id_loc; clty; ty_id; cltydef; obj_id; obj_abbr; cls_ty_decl = cltydef; cls_obj_id = obj_id; cls_obj_abbr = obj_abbr; - cls_typesharp_id = cl_id; cls_abbr = cl_abbr; cls_arity = arity; cls_pub_methods = pub_meths; @@ -1847,19 +1848,21 @@ let type_classes define_class approx kind env cls = Ident.create_scoped ~scope cl.pci_name.txt, Ident.create_scoped ~scope cl.pci_name.txt, Ident.create_scoped ~scope cl.pci_name.txt, - Ident.create_scoped ~scope ("#" ^ cl.pci_name.txt), Uid.mk ~current_unit:(Env.get_unit_name ()) )) cls in - Ctype.begin_class_def (); - let (res, newenv) = - List.fold_left (initial_env define_class approx) ([], env) cls - in - let (res, newenv) = - List.fold_right (class_infos define_class kind) res ([], newenv) + let res, newenv = + Ctype.with_local_level_for_class begin fun () -> + let (res, env) = + List.fold_left (initial_env define_class approx) ([], env) cls + in + let (res, env) = + List.fold_right (class_infos define_class kind) res ([], env) + in + res, env + end in - Ctype.end_def (); let res = List.rev_map (final_decl newenv define_class) res in let decls = List.fold_right extract_type_decls res [] in let decls = @@ -1915,7 +1918,6 @@ let class_type_declarations env cls = clsty_ty_decl = decl.cls_ty_decl; clsty_obj_id = decl.cls_obj_id; clsty_obj_abbr = decl.cls_obj_abbr; - clsty_typesharp_id = decl.cls_typesharp_id; clsty_abbr = decl.cls_abbr; clsty_info = decl.cls_info}) decls, @@ -1936,6 +1938,32 @@ let () = (*******************************) +(* Check that there is no references through recursive modules (GPR#6491) *) +let rec check_recmod_class_type env cty = + match cty.pcty_desc with + | Pcty_constr(lid, _) -> + ignore (Env.lookup_cltype ~use:false ~loc:lid.loc lid.txt env) + | Pcty_extension _ -> () + | Pcty_arrow(_, _, cty) -> + check_recmod_class_type env cty + | Pcty_open(od, cty) -> + let _, env = !type_open_descr env od in + check_recmod_class_type env cty + | Pcty_signature csig -> + check_recmod_class_sig env csig + +and check_recmod_class_sig env csig = + List.iter + (fun ctf -> + match ctf.pctf_desc with + | Pctf_inherit cty -> check_recmod_class_type env cty + | Pctf_val _ | Pctf_method _ + | Pctf_constraint _ | Pctf_attribute _ | Pctf_extension _ -> ()) + csig.pcsig_fields + +let check_recmod_decl env sdecl = + check_recmod_class_type env sdecl.pci_expr + (* Approximate the class declaration as class ['params] id = object end *) let approx_class sdecl = let open Ast_helper in @@ -1944,7 +1972,9 @@ let approx_class sdecl = { sdecl with pci_expr = clty' } let approx_class_declarations env sdecls = - fst (class_type_declarations env (List.map approx_class sdecls)) + let decls, env = class_type_declarations env (List.map approx_class sdecls) in + List.iter (check_recmod_decl env) sdecls; + decls, env (*******************************) @@ -1952,12 +1982,19 @@ let approx_class_declarations env sdecls = open Format -let non_virtual_string_of_kind = function +let non_virtual_string_of_kind : kind -> string = function | Object -> "object" | Class -> "non-virtual class" | Class_type -> "non-virtual class type" -let report_error env ppf = function +module Style=Misc.Style + +let report_error env ppf = + let pp_args ppf args = + let args = List.map (Printtyp.tree_of_typexp Type) args in + Style.as_inline_code !Oprint.out_type_args ppf args + in + function | Repeated_parameter -> fprintf ppf "A type parameter occurs several times" | Unconsistent_constraint err -> @@ -1969,50 +2006,58 @@ let report_error env ppf = function | Field_type_mismatch (k, m, err) -> Printtyp.report_unification_error ppf env err (function ppf -> - fprintf ppf "The %s %s@ has type" k m) + fprintf ppf "The %s %a@ has type" k Style.inline_code m) (function ppf -> fprintf ppf "but is expected to have type") | Unexpected_field (ty, lab) -> fprintf ppf "@[@[<2>This object is expected to have type :@ %a@]\ - @ This type does not have a method %s." - Printtyp.type_expr ty lab + @ This type does not have a method %a." + (Style.as_inline_code Printtyp.type_expr) ty + Style.inline_code lab | Structure_expected clty -> fprintf ppf "@[This class expression is not a class structure; it has type@ %a@]" - Printtyp.class_type clty + (Style.as_inline_code Printtyp.class_type) clty | Cannot_apply _ -> fprintf ppf "This class expression is not a class function, it cannot be applied" | Apply_wrong_label l -> - let mark_label = function - | Nolabel -> "out label" - | l -> sprintf " label %s" (Btype.prefixed_label_name l) in - fprintf ppf "This argument cannot be applied with%s" (mark_label l) + let mark_label ppf = function + | Nolabel -> fprintf ppf "without label" + | l -> fprintf ppf "with label %a" + Style.inline_code (Btype.prefixed_label_name l) + in + fprintf ppf "This argument cannot be applied %a" mark_label l | Pattern_type_clash ty -> (* XXX Trace *) (* XXX Revoir message d'erreur | Improve error message *) fprintf ppf "@[%s@ %a@]" "This pattern cannot match self: it only matches values of type" - Printtyp.type_expr ty + (Style.as_inline_code Printtyp.type_expr) ty | Unbound_class_2 cl -> fprintf ppf "@[The class@ %a@ is not yet completely defined@]" - Printtyp.longident cl + (Style.as_inline_code Printtyp.longident) cl | Unbound_class_type_2 cl -> fprintf ppf "@[The class type@ %a@ is not yet completely defined@]" - Printtyp.longident cl + (Style.as_inline_code Printtyp.longident) cl | Abbrev_type_clash (abbrev, actual, expected) -> (* XXX Afficher une trace ? | Print a trace? *) Printtyp.prepare_for_printing [abbrev; actual; expected]; fprintf ppf "@[The abbreviation@ %a@ expands to type@ %a@ \ but is used with type@ %a@]" - !Oprint.out_type (Printtyp.tree_of_typexp Type abbrev) - !Oprint.out_type (Printtyp.tree_of_typexp Type actual) - !Oprint.out_type (Printtyp.tree_of_typexp Type expected) + (Style.as_inline_code !Oprint.out_type) + (Printtyp.tree_of_typexp Type abbrev) + (Style.as_inline_code !Oprint.out_type) + (Printtyp.tree_of_typexp Type actual) + (Style.as_inline_code !Oprint.out_type) + (Printtyp.tree_of_typexp Type expected) | Constructor_type_mismatch (c, err) -> Printtyp.report_unification_error ppf env err (function ppf -> - fprintf ppf "The expression \"new %s\" has type" c) + fprintf ppf "The expression %a has type" + Style.inline_code ("new " ^ c) + ) (function ppf -> fprintf ppf "but is used with type") | Virtual_class (kind, mets, vals) -> @@ -2027,18 +2072,18 @@ let report_error env ppf = function "@[This %s has virtual %s.@ \ @[<2>The following %s are virtual : %a@]@]" kind missings missings - (pp_print_list ~pp_sep:pp_print_space pp_print_string) (mets @ vals) + (pp_print_list ~pp_sep:pp_print_space Style.inline_code) (mets @ vals) | Undeclared_methods(kind, mets) -> let kind = non_virtual_string_of_kind kind in fprintf ppf "@[This %s has undeclared virtual methods.@ \ @[<2>The following methods were not declared : %a@]@]" - kind (pp_print_list ~pp_sep:pp_print_space pp_print_string) mets + kind (pp_print_list ~pp_sep:pp_print_space Style.inline_code) mets | Parameter_arity_mismatch(lid, expected, provided) -> fprintf ppf "@[The class constructor %a@ expects %i type argument(s),@ \ but is here applied to %i type argument(s)@]" - Printtyp.longident lid expected provided + (Style.as_inline_code Printtyp.longident) lid expected provided | Parameter_mismatch err -> Printtyp.report_unification_error ppf env err (function ppf -> @@ -2046,49 +2091,71 @@ let report_error env ppf = function (function ppf -> fprintf ppf "does not meet its constraint: it should be") | Bad_parameters (id, params, cstrs) -> - Printtyp.prepare_for_printing [params; cstrs]; + Printtyp.prepare_for_printing (params @ cstrs); + fprintf ppf + "@[The abbreviation %a@ is used with parameter(s)@ %a@ \ + which are incompatible with constraint(s)@ %a@]" + (Style.as_inline_code Printtyp.ident) id + pp_args params + pp_args cstrs + | Bad_class_type_parameters (id, params, cstrs) -> + let pp_hash ppf id = fprintf ppf "#%a" Printtyp.ident id in + Printtyp.prepare_for_printing (params @ cstrs); fprintf ppf - "@[The abbreviation %a@ is used with parameters@ %a@ \ - which are incompatible with constraints@ %a@]" - Printtyp.ident id - !Oprint.out_type (Printtyp.tree_of_typexp Type params) - !Oprint.out_type (Printtyp.tree_of_typexp Type cstrs) + "@[The class type %a@ is used with parameter(s)@ %a,@ \ + whereas the class type definition@ constrains@ \ + those parameters to be@ %a@]" + (Style.as_inline_code pp_hash) id + pp_args params + pp_args cstrs | Class_match_failure error -> Includeclass.report_error Type ppf error | Unbound_val lab -> - fprintf ppf "Unbound instance variable %s" lab + fprintf ppf "Unbound instance variable %a" Style.inline_code lab | Unbound_type_var (printer, reason) -> - let print_reason ppf (ty0, real, lab, ty) = + let print_reason ppf { Ctype.free_variable; meth; meth_ty; } = + let (ty0, kind) = free_variable in let ty1 = - if real then ty0 else Btype.newgenty(Tobject(ty0, ref None)) in - Printtyp.add_type_to_preparation ty; + match kind with + | Type_variable -> ty0 + | Row_variable -> Btype.newgenty(Tobject(ty0, ref None)) + in + Printtyp.add_type_to_preparation meth_ty; Printtyp.add_type_to_preparation ty1; + let pp_type ppf ty = Style.as_inline_code !Oprint.out_type ppf ty in fprintf ppf - "The method %s@ has type@;<1 2>%a@ where@ %a@ is unbound" - lab - !Oprint.out_type (Printtyp.tree_of_typexp Type ty) - !Oprint.out_type (Printtyp.tree_of_typexp Type ty0) + "The method %a@ has type@;<1 2>%a@ where@ %a@ is unbound" + Style.inline_code meth + pp_type (Printtyp.tree_of_typexp Type meth_ty) + pp_type (Printtyp.tree_of_typexp Type ty0) in fprintf ppf "@[@[Some type variables are unbound in this type:@;<1 2>%t@]@ \ @[%a@]@]" printer print_reason reason - | Non_generalizable_class (id, clty) -> + | Non_generalizable_class {id; clty; nongen_vars } -> + let[@manual.ref "ss:valuerestriction"] manual_ref = [ 6; 1; 2] in + Printtyp.prepare_for_printing nongen_vars; fprintf ppf "@[The type of this class,@ %a,@ \ - contains type variables that cannot be generalized@]" - (Printtyp.class_declaration id) clty + contains the non-generalizable type variable(s): %a.@ %a@]" + (Style.as_inline_code @@ Printtyp.class_declaration id) clty + (pp_print_list ~pp_sep:(fun f () -> fprintf f ",@ ") + (Style.as_inline_code Printtyp.prepared_type_scheme) + ) nongen_vars + Misc.print_see_manual manual_ref + | Cannot_coerce_self ty -> fprintf ppf "@[The type of self cannot be coerced to@ \ the type of the current class:@ %a.@.\ Some occurrences are contravariant@]" - Printtyp.type_scheme ty + (Style.as_inline_code Printtyp.type_scheme) ty | Non_collapsable_conjunction (id, clty, err) -> fprintf ppf "@[The type of this class,@ %a,@ \ contains non-collapsible conjunctive types in constraints.@ %t@]" - (Printtyp.class_declaration id) clty + (Style.as_inline_code @@ Printtyp.class_declaration id) clty (fun ppf -> Printtyp.report_unification_error ppf env err (fun ppf -> fprintf ppf "Type") (fun ppf -> fprintf ppf "is not compatible with type") @@ -2107,19 +2174,23 @@ let report_error env ppf = function "@[The instance variable is %s;@ it cannot be redefined as %s@]" mut1 mut2 | No_overriding (_, "") -> - fprintf ppf "@[This inheritance does not override any method@ %s@]" - "instance variable" + fprintf ppf + "@[This inheritance does not override any methods@ \ + or instance variables@ but is explicitly marked as@ \ + overriding with %a.@]" + Style.inline_code "!" | No_overriding (kind, name) -> - fprintf ppf "@[The %s `%s'@ has no previous definition@]" kind name + fprintf ppf "@[The %s %a@ has no previous definition@]" kind + Style.inline_code name | Duplicate (kind, name) -> - fprintf ppf "@[The %s `%s'@ has multiple definitions in this object@]" - kind name + fprintf ppf "@[The %s %a@ has multiple definitions in this object@]" + kind Style.inline_code name | Closing_self_type sign -> fprintf ppf "@[Cannot close type of object literal:@ %a@,\ it has been unified with the self type of a class that is not yet@ \ completely defined.@]" - Printtyp.type_scheme sign.csig_self + (Style.as_inline_code Printtyp.type_scheme) sign.csig_self let report_error env ppf err = Printtyp.wrap_printing_env ~error:true diff --git a/src/ocaml/typing/typeclass.mli b/src/ocaml/typing/typeclass.mli index bf89e44648..cdecc8dfb7 100644 --- a/src/ocaml/typing/typeclass.mli +++ b/src/ocaml/typing/typeclass.mli @@ -25,7 +25,6 @@ type 'a class_info = { cls_ty_decl : class_type_declaration; cls_obj_id : Ident.t; cls_obj_abbr : type_declaration; - cls_typesharp_id : Ident.t; cls_abbr : type_declaration; cls_arity : int; cls_pub_methods : string list; @@ -38,7 +37,6 @@ type class_type_info = { clsty_ty_decl : class_type_declaration; clsty_obj_id : Ident.t; clsty_obj_abbr : type_declaration; - clsty_typesharp_id : Ident.t; clsty_abbr : type_declaration; clsty_info : Typedtree.class_type_declaration; } @@ -70,7 +68,7 @@ and class_type_declaration = *) val approx_class_declarations: - Env.t -> Parsetree.class_description list -> class_type_info list + Env.t -> Parsetree.class_description list -> class_type_info list * Env.t (* val type_classes : @@ -109,12 +107,16 @@ type error = | Undeclared_methods of kind * string list | Parameter_arity_mismatch of Longident.t * int * int | Parameter_mismatch of Errortrace.unification_error - | Bad_parameters of Ident.t * type_expr * type_expr + | Bad_parameters of Ident.t * type_expr list * type_expr list + | Bad_class_type_parameters of Ident.t * type_expr list * type_expr list | Class_match_failure of Ctype.class_match_failure list | Unbound_val of string - | Unbound_type_var of - (formatter -> unit) * (type_expr * bool * string * type_expr) - | Non_generalizable_class of Ident.t * Types.class_declaration + | Unbound_type_var of (formatter -> unit) * Ctype.closed_class_failure + | Non_generalizable_class of + { id : Ident.t + ; clty : Types.class_declaration + ; nongen_vars : type_expr list + } | Cannot_coerce_self of type_expr | Non_collapsable_conjunction of Ident.t * Types.class_declaration * Errortrace.unification_error diff --git a/src/ocaml/typing/typecore.ml b/src/ocaml/typing/typecore.ml index f83421683b..605b6823bf 100644 --- a/src/ocaml/typing/typecore.ml +++ b/src/ocaml/typing/typecore.ml @@ -15,6 +15,9 @@ (* Typechecking for the core language *) +[@@@ocaml.warning "-60"] module Str = Ast_helper.Str (* For ocamldep *) +[@@@ocaml.warning "+60"] + open Misc open Asttypes open Parsetree @@ -25,6 +28,8 @@ open Ctype let raise_error = Msupport.raise_error +module Style = Misc.Style + type type_forcing_context = | If_conditional | If_no_else_branch @@ -42,12 +47,6 @@ type type_expected = { explanation: type_forcing_context option; } -type to_unpack = { - tu_name: string Location.loc; - tu_loc: Location.t; - tu_uid: Uid.t -} - module Datatype_kind = struct type t = Record | Variant @@ -78,6 +77,10 @@ type wrong_kind_sort = | List | Unit +type contains_gadt = + | Contains_gadt + | No_gadt + let wrong_kind_sort_of_constructor (lid : Longident.t) = match lid with | Lident "true" | Lident "false" | Ldot(_, "true") | Ldot(_, "false") -> @@ -99,14 +102,38 @@ type error = | Constructor_arity_mismatch of Longident.t * int * int | Label_mismatch of Longident.t * Errortrace.unification_error | Pattern_type_clash : - Errortrace.unification_error * _ pattern_desc option -> error + Errortrace.unification_error * Parsetree.pattern_desc option -> error | Or_pattern_type_clash of Ident.t * Errortrace.unification_error | Multiply_bound_variable of string | Orpat_vars of Ident.t * Ident.t list | Expr_type_clash of Errortrace.unification_error * type_forcing_context option - * expression_desc option - | Apply_non_function of type_expr + * Parsetree.expression_desc option + | Function_arity_type_clash of + { syntactic_arity : int; + type_constraint : type_expr; + trace : Errortrace.unification_error; + } + (* [Function_arity_type_clash { syntactic_arity = n; type_constraint; trace }] + is the type error for the specific case where an n-ary function is + constrained at a type with an arity less than n, e.g.: + {[ + type (_, _) eq = Eq : ('a, 'a) eq + let bad : type a. ?opt:(a, int -> int) eq -> unit -> a = + fun ?opt:(Eq = assert false) () x -> x + 1 + ]} + + [type_constraint] is the user-written polymorphic type (in this example + [?opt:(a, int -> int) eq -> unit -> a]) that causes this type clash, and + [trace] is the unification error that signaled the issue. + *) + | Apply_non_function of { + funct : Typedtree.expression; + func_ty : type_expr; + res_ty : type_expr; + previous_arg_loc : Location.t; + extra_arg_loc : Location.t; + } | Apply_wrong_label of arg_label * type_expr * bool | Label_multiply_defined of string | Label_missing of Ident.t list @@ -144,7 +171,7 @@ type error = | Modules_not_allowed | Cannot_infer_signature | Not_a_packed_module of type_expr - | Unexpected_existential of existential_restriction * string * string list + | Unexpected_existential of existential_restriction * string | Invalid_interval | Invalid_for_loop_index | No_value_clauses @@ -233,7 +260,9 @@ let error (loc, env, err) = | Expr_type_clash (trace, ctx_opt, eopt) -> Expr_type_clash (trace_copy trace, ctx_opt, eopt) | Apply_non_function t -> - Apply_non_function (deep_copy () t) + Apply_non_function { t with + func_ty = deep_copy () t.func_ty; + res_ty = deep_copy () t.res_ty } | Apply_wrong_label (l, t, b) -> Apply_wrong_label (l, deep_copy () t, b) | Wrong_name (s1, t, wn) -> @@ -307,15 +336,15 @@ let type_object = let re node = Cmt_format.add_saved_type (Cmt_format.Partial_expression node); node -;; + let rp node = Cmt_format.add_saved_type (Cmt_format.Partial_pattern (Value, node)); node -;; + let rcp node = Cmt_format.add_saved_type (Cmt_format.Partial_pattern (Computation, node)); node -;; + (* Context for inline record arguments; see [type_ident] *) @@ -325,7 +354,6 @@ type recarg = | Required | Rejected - let mk_expected ?explanation ty = { ty; explanation; } let case lhs rhs = @@ -399,13 +427,19 @@ let extract_option_type env ty = Tconstr(path, [ty], _) when Path.same path Predef.path_option -> ty | _ -> assert false +let protect_expansion env ty = + if Env.has_local_constraints env then generic_instance ty else ty + type record_extraction_result = | Record_type of Path.t * Path.t * Types.label_declaration list | Not_a_record_type | Maybe_a_record_type +let extract_concrete_typedecl_protected env ty = + extract_concrete_typedecl env (protect_expansion env ty) + let extract_concrete_record env ty = - match extract_concrete_typedecl env ty with + match extract_concrete_typedecl_protected env ty with | Typedecl(p0, p, {type_kind=Type_record (fields, _)}) -> Record_type (p0, p, fields) | Has_no_typedecl | Typedecl(_, _, _) -> Not_a_record_type @@ -417,7 +451,7 @@ type variant_extraction_result = | Maybe_a_variant_type let extract_concrete_variant env ty = - match extract_concrete_typedecl env ty with + match extract_concrete_typedecl_protected env ty with | Typedecl(p0, p, {type_kind=Type_variant (cstrs, _)}) -> Variant_type (p0, p, cstrs) | Typedecl(p0, p, {type_kind=Type_open}) -> @@ -447,46 +481,45 @@ let unify_exp_types loc env ty expected_ty = | Tags(l1,l2) -> raise(Typetexp.Error(loc, env, Typetexp.Variant_tags (l1, l2))) -(* level at which to create the local type declarations *) -let gadt_equations_level = ref None -let get_gadt_equations_level () = - match !gadt_equations_level with - Some y -> y - | None -> assert false +(* helper notation for Pattern_env.t *) +let (!!) (penv : Pattern_env.t) = penv.env -let nothing_equated = TypePairs.create 0 +(* Unification inside type_pat *) +let unify_pat_types loc env ty ty' = + try unify env ty ty' with + | Unify err -> + raise(Error(loc, env, Pattern_type_clash(err, None))) + | Tags(l1,l2) -> + raise(Typetexp.Error(loc, env, Typetexp.Variant_tags (l1, l2))) -(* unification inside type_pat*) -let unify_pat_types_return_equated_pairs ?(refine = None) loc env ty ty' = +(* GADT unification inside solve_Ppat_construct and check_counter_example_pat *) +let nothing_equated = TypePairs.create 0 +let unify_pat_types_return_equated_pairs ~refine loc penv ty ty' = try - match refine with - | Some allow_recursive -> - unify_gadt ~equations_level:(get_gadt_equations_level ()) - ~allow_recursive env ty ty' - | None -> - unify !env ty ty'; - nothing_equated + if refine then unify_gadt penv ty ty' + else (unify !!penv ty ty'; nothing_equated) with | Unify err -> - raise(error(loc, !env, Pattern_type_clash(err, None))) + raise(error(loc, !!penv, Pattern_type_clash(err, None))) | Tags(l1,l2) -> - raise(Typetexp.Error(loc, !env, Typetexp.Variant_tags (l1, l2))) + raise(Typetexp.Error(loc, !!penv, Typetexp.Variant_tags (l1, l2))) -let unify_pat_types ?refine loc env ty ty' = - ignore (unify_pat_types_return_equated_pairs ?refine loc env ty ty') +let unify_pat_types_refine ~refine loc penv ty ty' = + ignore (unify_pat_types_return_equated_pairs ~refine loc penv ty ty') - -let unify_pat ?refine env pat expected_ty = - try unify_pat_types ?refine pat.pat_loc env pat.pat_type expected_ty +(** [sdesc_for_hint] is used by error messages to report literals in their + original formatting *) +let unify_pat ?sdesc_for_hint env pat expected_ty = + try unify_pat_types pat.pat_loc env pat.pat_type expected_ty with Error (loc, env, Pattern_type_clash(err, None)) -> - raise(Error(loc, env, Pattern_type_clash(err, Some pat.pat_desc))) + raise(error(loc, env, Pattern_type_clash(err, sdesc_for_hint))) (* unification of a type with a Tconstr with freshly created arguments *) -let unify_head_only ~refine loc env ty constr = +let unify_head_only ~refine loc penv ty constr = let path = cstr_type_path constr in - let decl = Env.find_type path !env in + let decl = Env.find_type path !!penv in let ty' = Ctype.newconstr path (Ctype.instance_list decl.type_params) in - unify_pat_types ~refine loc env ty' ty + unify_pat_types_refine ~refine loc penv ty' ty (* Creating new conjunctive types is not allowed when typing patterns *) (* make all Reither present in open variants *) @@ -504,8 +537,7 @@ let finalize_variant pat tag opat r = | Reither (false, ty::tl, _) when not (row_closed row) -> link_row_field_ext ~inside:f (rf_present (Some ty)); begin match opat with None -> assert false - | Some pat -> - let env = ref pat.pat_env in List.iter (unify_pat env pat) (ty::tl) + | Some pat -> List.iter (unify_pat pat.pat_env pat) (ty::tl) end | Reither (c, _l, true) when not (has_fixed_explanation row) -> link_row_field_ext ~inside:f (rf_either [] ~no_arg:c ~matched:false) @@ -529,7 +561,9 @@ let finalize_variants p = finalize_variant p tag opat r | _ -> () } p -(* pattern environment *) +(* [type_pat_state] and related types for pattern environment; + these should not be confused with Pattern_env.t, which is a part of the + interface to unification functions in [Ctype] *) type pattern_variable = { pv_id: Ident.t; @@ -537,20 +571,83 @@ type pattern_variable = pv_loc: Location.t; pv_as_var: bool; pv_attributes: attributes; + pv_uid : Uid.t; } type module_variable = - string loc * Location.t - -let pattern_variables = ref ([] : pattern_variable list) -let pattern_force = ref ([] : (unit -> unit) list) -let allow_modules = ref false -let module_variables = ref ([] : module_variable list) -let reset_pattern allow = - pattern_variables := []; - pattern_force := []; - allow_modules := allow; - module_variables := []; + { + mv_id: Ident.t; + mv_name: string Location.loc; + mv_loc: Location.t; + mv_uid: Uid.t + } + +(* Whether or not patterns of the form (module M) are accepted. (If they are, + the idents will be created at the provided scope.) When module patterns are + allowed, the caller should take care to check that the introduced module + bindings' types don't escape their scope; see the callsites in [type_let] + and [type_cases] for examples. + [Modules_ignored] indicates that the typing of patterns should not accumulate + a list of module patterns to unpack. It's no different than using + [Modules_allowed] and then ignoring the accumulated [module_variables] list, + but signals more clearly that the module patterns aren't used in an + interesting way. +*) +type module_patterns_restriction = + | Modules_allowed of { scope: int } + | Modules_rejected + | Modules_ignored + +(* A parallel type to [module_patterns_restriction], though also + tracking the module variables encountered. +*) +type module_variables = + | Modvars_allowed of + { scope: int; + module_variables: module_variable list; + } + | Modvars_rejected + | Modvars_ignored + +type type_pat_state = + { mutable tps_pattern_variables: pattern_variable list; + mutable tps_pattern_force: (unit -> unit) list; + mutable tps_module_variables: module_variables; + (* Mutation will not change the constructor of [tps_module_variables], just + the contained [module_variables] list. [module_variables] could be made + mutable instead, but we felt this made the code more awkward. + *) + } + +let create_type_pat_state allow_modules = + let tps_module_variables = + match allow_modules with + | Modules_allowed { scope } -> + Modvars_allowed { scope; module_variables = [] } + | Modules_ignored -> Modvars_ignored + | Modules_rejected -> Modvars_rejected + in + { tps_pattern_variables = []; + tps_module_variables; + tps_pattern_force = []; + } + +(* Copy mutable fields. Used in typechecking or-patterns. *) +let copy_type_pat_state + { tps_pattern_variables; + tps_module_variables; + tps_pattern_force; + } + = + { tps_pattern_variables; + tps_module_variables; + tps_pattern_force; + } + +let blit_type_pat_state ~src ~dst = + dst.tps_pattern_variables <- src.tps_pattern_variables; + dst.tps_module_variables <- src.tps_module_variables; + dst.tps_pattern_force <- src.tps_pattern_force; ;; let maybe_add_pattern_variables_ghost loc_let env pv = @@ -564,25 +661,45 @@ let maybe_add_pattern_variables_ghost loc_let env pv = end ) pv env -let enter_variable ?(is_module=false) ?(is_as_variable=false) loc name ty +let enter_variable ?(is_module=false) ?(is_as_variable=false) tps loc name ty attrs = if List.exists (fun {pv_id; _} -> Ident.name pv_id = name.txt) - !pattern_variables + tps.tps_pattern_variables then raise(error(loc, Env.empty, Multiply_bound_variable name.txt)); - let id = Ident.create_local name.txt in - pattern_variables := + let id = + if is_module then begin + (* Unpack patterns result in both a module declaration and a value + variable of the same name being entered into the environment. (The + module is via [tps_module_variables], and the variable is via + [tps_pattern_variables].) *) + match tps.tps_module_variables with + | Modvars_ignored -> Ident.create_local name.txt + | Modvars_rejected -> + raise (error (loc, Env.empty, Modules_not_allowed)); + | Modvars_allowed { scope; module_variables } -> + let id = Ident.create_scoped name.txt ~scope in + let module_variables = + { mv_id = id; + mv_name = name; + mv_loc = loc; + mv_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); + } :: module_variables + in + tps.tps_module_variables <- + Modvars_allowed { scope; module_variables; }; + id + end else + Ident.create_local name.txt + in + let pv_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) in + tps.tps_pattern_variables <- {pv_id = id; pv_type = ty; pv_loc = loc; pv_as_var = is_as_variable; - pv_attributes = attrs} :: !pattern_variables; - if is_module then begin - (* Note: unpack patterns enter a variable of the same name *) - if not !allow_modules then - raise (error (loc, Env.empty, Modules_not_allowed)); - module_variables := (name, loc) :: !module_variables - end; - id + pv_attributes = attrs; + pv_uid} :: tps.tps_pattern_variables; + id, pv_uid let sort_pattern_variables vs = List.sort @@ -624,31 +741,35 @@ let enter_orpat_variables loc env p1_vs p2_vs = raise (error (loc, env, err)) in unify_vars p1_vs p2_vs -let rec build_as_type ~refine (env : Env.t ref) p = - let as_ty = build_as_type_aux ~refine env p in - (* Cf. #1655 *) - List.fold_left (fun as_ty (extra, _loc, _attrs) -> - match extra with - | Tpat_type _ | Tpat_open _ | Tpat_unpack -> as_ty - | Tpat_constraint cty -> +let rec build_as_type (env : Env.t) p = + build_as_type_extra env p p.pat_extra + +and build_as_type_extra env p = function + | [] -> build_as_type_aux env p + | ((Tpat_type _ | Tpat_open _ | Tpat_unpack), _, _) :: rest -> + build_as_type_extra env p rest + | (Tpat_constraint {ctyp_type = ty; _}, _, _) :: rest -> + (* If the type constraint is ground, then this is the best type + we can return, so just return an instance (cf. #12313) *) + if free_variables ty = [] then instance ty else + (* Otherwise we combine the inferred type for the pattern with + then non-ground constraint in a non-ambivalent way *) + let as_ty = build_as_type_extra env p rest in (* [generic_instance] can only be used if the variables of the original type ([cty.ctyp_type] here) are not at [generic_level], which they are here. If we used [generic_instance] we would lose the sharing between [instance ty] and [ty]. *) - begin_def (); - let ty = instance cty.ctyp_type in - end_def (); - generalize_structure ty; - (* This call to unify can't fail since the pattern is well typed. *) - unify_pat_types ~refine p.pat_loc env (instance as_ty) (instance ty); + let ty = + with_local_level ~post:generalize_structure (fun () -> instance ty) + in + (* This call to unify may only fail due to missing GADT equations *) + unify_pat_types p.pat_loc env (instance as_ty) (instance ty); ty - ) as_ty p.pat_extra -and build_as_type_aux ~refine (env : Env.t ref) p = - let build_as_type = build_as_type ~refine in +and build_as_type_aux (env : Env.t) p = match p.pat_desc with - Tpat_alias(p1,_, _) -> build_as_type env p1 + Tpat_alias(p1,_, _, _) -> build_as_type env p1 | Tpat_tuple pl -> let tyl = List.map (build_as_type env) pl in newty (Ttuple tyl) @@ -658,8 +779,10 @@ and build_as_type_aux ~refine (env : Env.t ref) p = vto <> None (* be lazy and keep the type for node constraints *) in if keep then p.pat_type else let tyl = List.map (build_as_type env) pl in - let ty_args, ty_res, _ = instance_constructor cstr in - List.iter2 (fun (p,ty) -> unify_pat ~refine env {p with pat_type = ty}) + let ty_args, ty_res, _ = + instance_constructor Keep_existentials_flexible cstr + in + List.iter2 (fun (p,ty) -> unify_pat env {p with pat_type = ty}) (List.combine pl tyl) ty_args; ty_res | Tpat_variant(l, p', _) -> @@ -673,19 +796,18 @@ and build_as_type_aux ~refine (env : Env.t ref) p = let ty = newvar () in let ppl = List.map (fun (_, l, p) -> l.lbl_pos, p) lpl in let do_label lbl = - let _, ty_arg, ty_res = instance_label false lbl in - unify_pat ~refine env {p with pat_type = ty} ty_res; + let _, ty_arg, ty_res = instance_label ~fixed:false lbl in + unify_pat env {p with pat_type = ty} ty_res; let refinable = lbl.lbl_mut = Immutable && List.mem_assoc lbl.lbl_pos ppl && match get_desc lbl.lbl_arg with Tpoly _ -> false | _ -> true in if refinable then begin let arg = List.assoc lbl.lbl_pos ppl in - unify_pat ~refine env - {arg with pat_type = build_as_type env arg} ty_arg + unify_pat env {arg with pat_type = build_as_type env arg} ty_arg end else begin - let _, ty_arg', ty_res' = instance_label false lbl in - unify_pat_types ~refine p.pat_loc env ty_arg ty_arg'; - unify_pat ~refine env p ty_res' + let _, ty_arg', ty_res' = instance_label ~fixed:false lbl in + unify_pat_types p.pat_loc env ty_arg ty_arg'; + unify_pat env p ty_res' end in Array.iter do_label lbl.lbl_all; ty @@ -693,7 +815,7 @@ and build_as_type_aux ~refine (env : Env.t ref) p = begin match row with None -> let ty1 = build_as_type env p1 and ty2 = build_as_type env p2 in - unify_pat ~refine env {p2 with pat_type = ty2} ty1; + unify_pat env {p2 with pat_type = ty2} ty1; ty1 | Some row -> let Row {fields; fixed; name} = row_repr row in @@ -705,60 +827,57 @@ and build_as_type_aux ~refine (env : Env.t ref) p = (* Constraint solving during typing of patterns *) -let solve_Ppat_poly_constraint ~refine env loc sty expected_ty = - let cty, ty, force = Typetexp.transl_simple_type_delayed !env sty in - unify_pat_types ~refine loc env ty (instance expected_ty); - pattern_force := force :: !pattern_force; +let solve_Ppat_poly_constraint tps env loc sty expected_ty = + let cty, ty, force = Typetexp.transl_simple_type_delayed env sty in + unify_pat_types loc env ty (instance expected_ty); + tps.tps_pattern_force <- force :: tps.tps_pattern_force; match get_desc ty with | Tpoly (body, tyl) -> - begin_def (); - init_def generic_level; - let _, ty' = instance_poly ~keep_names:true false tyl body in - end_def (); + let _, ty' = + with_level ~level:generic_level + (fun () -> instance_poly ~keep_names:true ~fixed:false tyl body) + in (cty, ty, ty') | _ -> assert false -let solve_Ppat_alias ~refine env pat = - begin_def (); - let ty_var = build_as_type ~refine env pat in - end_def (); - generalize ty_var; - ty_var +let solve_Ppat_alias env pat = + with_local_level ~post:generalize (fun () -> build_as_type env pat) let solve_Ppat_tuple (type a) ~refine loc env (args : a list) expected_ty = let vars = List.map (fun _ -> newgenvar ()) args in let ty = newgenty (Ttuple vars) in let expected_ty = generic_instance expected_ty in - unify_pat_types ~refine loc env ty expected_ty; + unify_pat_types_refine ~refine loc env ty expected_ty; vars -let solve_constructor_annotation env name_list sty ty_args ty_ex = - let expansion_scope = get_gadt_equations_level () in +let solve_constructor_annotation + tps (penv : Pattern_env.t) name_list sty ty_args ty_ex = + let expansion_scope = penv.equations_scope in let ids = List.map (fun name -> - let decl = new_local_type ~loc:name.loc () in + let decl = new_local_type ~loc:name.loc Definition in let (id, new_env) = - Env.enter_type ~scope:expansion_scope name.txt decl !env in - env := new_env; + Env.enter_type ~scope:expansion_scope name.txt decl !!penv in + Pattern_env.set_env penv new_env; {name with txt = id}) name_list in - begin_def (); - let cty, ty, force = Typetexp.transl_simple_type_delayed !env sty in - end_def (); - generalize_structure ty; - pattern_force := force :: !pattern_force; + let cty, ty, force = + with_local_level ~post:(fun (_,ty,_) -> generalize_structure ty) + (fun () -> Typetexp.transl_simple_type_delayed !!penv sty) + in + tps.tps_pattern_force <- force :: tps.tps_pattern_force; let ty_args = let ty1 = instance ty and ty2 = instance ty in match ty_args with [] -> assert false | [ty_arg] -> - unify_pat_types cty.ctyp_loc env ty1 ty_arg; + unify_pat_types cty.ctyp_loc !!penv ty1 ty_arg; [ty2] | _ -> - unify_pat_types cty.ctyp_loc env ty1 (newty (Ttuple ty_args)); - match get_desc (expand_head !env ty2) with + unify_pat_types cty.ctyp_loc !!penv ty1 (newty (Ttuple ty_args)); + match get_desc (expand_head !!penv ty2) with Ttuple tyl -> tyl | _ -> assert false in @@ -771,58 +890,66 @@ let solve_constructor_annotation env name_list sty ty_args ty_ex = Tconstr(Path.Pident id, [], _) when List.mem id rem -> list_remove id rem | _ -> - raise (Error (cty.ctyp_loc, !env, + raise (Error (cty.ctyp_loc, !!penv, Unbound_existential (ids, ty)))) ids ty_ex in if rem <> [] then - raise (Error (cty.ctyp_loc, !env, + raise (Error (cty.ctyp_loc, !!penv, Unbound_existential (ids, ty))) end; ty_args, Some (ids, cty) -let solve_Ppat_construct ~refine env loc constr no_existentials +let solve_Ppat_construct ~refine tps penv loc constr no_existentials existential_styp expected_ty = (* if constructor is gadt, we must verify that the expected type has the correct head *) if constr.cstr_generalized then - unify_head_only ~refine loc env (instance expected_ty) constr; - begin_def (); - let expected_ty = instance expected_ty in + unify_head_only ~refine loc penv (instance expected_ty) constr; + (* PR#7214: do not use gadt unification for toplevel lets *) - let unify_res ty_res = + let unify_res ty_res expected_ty = let refine = - match refine, no_existentials with - | None, None when constr.cstr_generalized -> Some false - | _ -> refine - in - unify_pat_types_return_equated_pairs ~refine loc env ty_res expected_ty + refine || constr.cstr_generalized && no_existentials = None in + unify_pat_types_return_equated_pairs ~refine loc penv ty_res expected_ty in - let expansion_scope = get_gadt_equations_level () in - let ty_args, ty_res, equated_types, existential_ctyp = - match existential_styp with - None -> - let ty_args, ty_res, _ = - instance_constructor ~in_pattern:(env, expansion_scope) constr in - ty_args, ty_res, unify_res ty_res, None - | Some (name_list, sty) -> - let in_pattern = - if name_list = [] then Some (env, expansion_scope) else None in - let ty_args, ty_res, ty_ex = - instance_constructor ?in_pattern constr in - let equated_types = unify_res ty_res in - let ty_args, existential_ctyp = - solve_constructor_annotation env name_list sty ty_args ty_ex in - ty_args, ty_res, equated_types, existential_ctyp + + let ty_args, equated_types, existential_ctyp = + with_local_level_iter ~post: generalize_structure begin fun () -> + let expected_ty = instance expected_ty in + let ty_args, ty_res, equated_types, existential_ctyp = + match existential_styp with + None -> + let ty_args, ty_res, _ = + instance_constructor (Make_existentials_abstract penv) constr + in + ty_args, ty_res, unify_res ty_res expected_ty, None + | Some (name_list, sty) -> + let existential_treatment = + if name_list = [] then + Make_existentials_abstract penv + else + (* we will unify them (in solve_constructor_annotation) with the + local types provided by the user *) + Keep_existentials_flexible + in + let ty_args, ty_res, ty_ex = + instance_constructor existential_treatment constr + in + let equated_types = unify_res ty_res expected_ty in + let ty_args, existential_ctyp = + solve_constructor_annotation tps penv name_list sty ty_args ty_ex + in + ty_args, ty_res, equated_types, existential_ctyp + in + if constr.cstr_existentials <> [] then + lower_variables_only !!penv penv.Pattern_env.equations_scope ty_res; + ((ty_args, equated_types, existential_ctyp), + expected_ty :: ty_res :: ty_args) + end in - if constr.cstr_existentials <> [] then - lower_variables_only !env expansion_scope ty_res; - end_def (); - generalize_structure expected_ty; - generalize_structure ty_res; - List.iter generalize_structure ty_args; - if !Clflags.principal && refine = None then begin - (* Do not warn for couter examples *) + if !Clflags.principal && not refine then begin + (* Do not warn for counter-examples *) let exception Warn_only_once in try TypePairs.iter @@ -845,41 +972,39 @@ let solve_Ppat_construct ~refine env loc constr no_existentials end; (ty_args, existential_ctyp) -let solve_Ppat_record_field ~refine loc env label label_lid record_ty = - begin_def (); - let (_, ty_arg, ty_res) = instance_label false label in - begin try - unify_pat_types ~refine loc env ty_res (instance record_ty) - with Error(_loc, _env, Pattern_type_clash(err, _)) -> - raise(error(label_lid.loc, !env, - Label_mismatch(label_lid.txt, err))) - end; - end_def (); - generalize_structure ty_res; - generalize_structure ty_arg; - ty_arg +let solve_Ppat_record_field ~refine loc penv label label_lid record_ty = + with_local_level_iter ~post:generalize_structure begin fun () -> + let (_, ty_arg, ty_res) = instance_label ~fixed:false label in + begin try + unify_pat_types_refine ~refine loc penv ty_res (instance record_ty) + with Error(_loc, _env, Pattern_type_clash(err, _)) -> + raise(error(label_lid.loc, !!penv, + Label_mismatch(label_lid.txt, err))) + end; + (ty_arg, [ty_res; ty_arg]) + end let solve_Ppat_array ~refine loc env expected_ty = let ty_elt = newgenvar() in let expected_ty = generic_instance expected_ty in - unify_pat_types ~refine + unify_pat_types_refine ~refine loc env (Predef.type_array ty_elt) expected_ty; ty_elt -let solve_Ppat_lazy ~refine loc env expected_ty = +let solve_Ppat_lazy ~refine loc env expected_ty = let nv = newgenvar () in - unify_pat_types ~refine loc env (Predef.type_lazy_t nv) + unify_pat_types_refine ~refine loc env (Predef.type_lazy_t nv) (generic_instance expected_ty); nv -let solve_Ppat_constraint ~refine loc env sty expected_ty = - begin_def(); - let cty, ty, force = Typetexp.transl_simple_type_delayed !env sty in - end_def(); - pattern_force := force :: !pattern_force; - generalize_structure ty; +let solve_Ppat_constraint tps loc env sty expected_ty = + let cty, ty, force = + with_local_level ~post:(fun (_, ty, _) -> generalize_structure ty) + (fun () -> Typetexp.transl_simple_type_delayed env sty) + in + tps.tps_pattern_force <- force :: tps.tps_pattern_force; let ty, expected_ty' = instance ty, ty in - unify_pat_types ~refine loc env ty (instance expected_ty); + unify_pat_types loc env ty (instance expected_ty); (cty, ty, expected_ty') let solve_Ppat_variant ~refine loc env tag no_arg expected_ty = @@ -893,7 +1018,7 @@ let solve_Ppat_variant ~refine loc env tag no_arg expected_ty = (* PR#7404: allow some_private_tag blindly, as it would not unify with the abstract row variable *) if tag <> Parmatch.some_private_tag then - unify_pat_types ~refine loc env (newgenty(Tvariant row)) expected_ty; + unify_pat_types_refine ~refine loc env (newgenty(Tvariant row)) expected_ty; (arg_type, make_row (newvar ()), instance expected_ty) (* Building the or-pattern corresponding to a polymorphic variant type *) @@ -950,19 +1075,6 @@ let build_or_pat env loc lid = pat pats in (path, rp { r with pat_loc = loc }) -let split_cases env cases = - let add_case lst case = function - | None -> lst - | Some c_lhs -> { case with c_lhs } :: lst - in - List.fold_right (fun ({ c_lhs; c_guard } as case) (vals, exns) -> - match split_pattern c_lhs with - | Some _, Some _ when c_guard <> None -> - raise (error (c_lhs.pat_loc, env, - Mixed_value_and_exception_patterns_under_guard)) - | vp, ep -> add_case vals case vp, add_case exns case ep - ) cases ([], []) - (* Type paths *) let rec expand_path env p = @@ -1044,7 +1156,7 @@ end) = struct [_] -> [] | _ -> let open Printtyp in wrap_printing_env ~error:true env (fun () -> - reset(); strings_of_paths Type tpaths) + reset(); strings_of_paths (Some Type) tpaths) let disambiguate_by_type env tpath lbls = match lbls with @@ -1273,7 +1385,52 @@ let disambiguate_lid_a_list loc closed env usage expected_type lid_a_list = disambiguate_label_by_ids closed ids in Label.disambiguate ~warn ~filter usage lid env expected_type scope in let lbl_a_list = - List.map (fun (lid,a) -> lid, process_label lid, a) lid_a_list in + (* If one label is qualified [{ foo = ...; M.bar = ... }], + we will disambiguate all labels using one of the qualifying modules, + as if the user had written [{ M.foo = ...; M.bar = ... }]. + + #11630: It is important to process first the + user-qualified labels, instead of processing all labels in + order, so that error messages coming from the lookup of + M (maybe no such module/path exists) are shown to the user + in context of a qualified field [M.bar] they wrote + themselves, instead of the "ghost" qualification [M.foo] + that does not come from the source program. *) + let lbl_list = + List.map (fun (lid, _) -> + match lid.txt with + | Longident.Ldot _ -> Some (process_label lid) + | _ -> None + ) lid_a_list + in + (* Find a module prefix (if any) to qualify unqualified labels *) + let qual = + List.find_map (function + | {txt = Longident.Ldot (modname, _); _}, _ -> Some modname + | _ -> None + ) lid_a_list + in + (* Prefix unqualified labels with [qual] and resolve them. + + Prefixing unqualified labels does not change the final + disambiguation result, it restricts the set of candidates + without removing any valid choice. + It matters if users activated warnings for ambiguous or + out-of-scope resolutions -- they get less warnings by + qualifying at least one of the fields. *) + List.map2 (fun lid_a lbl -> + match lbl, lid_a with + | Some lbl, (lid, a) -> lid, lbl, a + | None, (lid, a) -> + let qual_lid = + match qual, lid.txt with + | Some modname, Longident.Lident s -> + {lid with txt = Longident.Ldot (modname, s)} + | _ -> lid + in + lid, process_label qual_lid, a + ) lid_a_list lbl_list + in if !w_pr then Location.prerr_warning loc (Warnings.Not_principal "this type-based record disambiguation") @@ -1299,39 +1456,13 @@ let disambiguate_lid_a_list loc closed env usage expected_type lid_a_list = (Warnings.Name_out_of_scope (!w_scope_ty, List.rev !w_scope, true)); lbl_a_list -let rec find_record_qual = function - | [] -> None - | ({ txt = Longident.Ldot (modname, _) }, _) :: _ -> Some modname - | _ :: rest -> find_record_qual rest - let map_fold_cont f xs k = List.fold_right (fun x k ys -> f x (fun y -> k (y :: ys))) xs (fun ys -> k (List.rev ys)) [] -let type_label_a_list - ?labels loc closed env usage type_lbl_a expected_type lid_a_list k = +let type_label_a_list loc closed env usage type_lbl_a expected_type lid_a_list = let lbl_a_list = - match lid_a_list, labels with - ({txt=Longident.Lident s}, _)::_, Some labels when Hashtbl.mem labels s -> - (* Special case for rebuilt syntax trees *) - List.map - (function lid, a -> match lid.txt with - Longident.Lident s -> lid, Hashtbl.find labels s, a - | _ -> assert false) - lid_a_list - | _ -> - let lid_a_list = - match find_record_qual lid_a_list with - None -> lid_a_list - | Some modname -> - List.map - (fun (lid, a as lid_a) -> - match lid.txt with Longident.Lident s -> - {lid with txt=Longident.Ldot (modname, s)}, a - | _ -> lid_a) - lid_a_list - in - disambiguate_lid_a_list loc closed env usage expected_type lid_a_list + disambiguate_lid_a_list loc closed env usage expected_type lid_a_list in (* Invariant: records are sorted in the typed tree *) let lbl_a_list = @@ -1339,8 +1470,7 @@ let type_label_a_list (fun (_,lbl1,_) (_,lbl2,_) -> compare lbl1.lbl_pos lbl2.lbl_pos) lbl_a_list in - map_fold_cont type_lbl_a lbl_a_list k -;; + List.map type_lbl_a lbl_a_list (* Checks over the labels mentioned in a record pattern: no duplicate definitions (error); properly closed (warning) *) @@ -1398,19 +1528,39 @@ end) (* Typing of patterns *) -(* "half typed" cases are produced in [type_cases] when we've just typechecked - the pattern but haven't type-checked the body yet. - At this point we might have added some type equalities to the environment, - but haven't yet added identifiers bound by the pattern. *) -type 'case_pattern half_typed_case = +(* "untyped" cases are prior to checking the pattern. *) +type untyped_case = Parsetree.pattern Parmatch.parmatch_case + +(* "half typed" cases are produced in [map_half_typed_cases] when we've just + typechecked the pattern but haven't type-checked the body yet. At this point + we might have added some type equalities to the environment, but haven't yet + added identifiers bound by the pattern. *) +type ('case_pattern, 'case_data) half_typed_case = { typed_pat: 'case_pattern; pat_type_for_unif: type_expr; - untyped_case: Parsetree.case; + untyped_case : untyped_case; + case_data : 'case_data; branch_env: Env.t; pat_vars: pattern_variable list; - unpacks: module_variable list; + module_vars: module_variables; contains_gadt: bool; } +(* Used to split patterns into value cases and exception cases. *) +let split_half_typed_cases env zipped_cases = + let add_case lst htc data = function + | None -> lst + | Some split_pat -> + ({ htc.untyped_case with pattern = split_pat }, data) :: lst + in + List.fold_right (fun (htc, data) (vals, exns) -> + let pat = htc.typed_pat in + match split_pattern pat with + | Some _, Some _ when htc.untyped_case.has_guard -> + raise (Error (pat.pat_loc, env, + Mixed_value_and_exception_patterns_under_guard)) + | vp, ep -> add_case vals htc data vp, add_case exns htc data ep + ) zipped_cases ([], []) + let rec has_literal_pattern p = match p.ppat_desc with | Ppat_constant _ | Ppat_interval _ -> @@ -1449,186 +1599,6 @@ let check_scope_escape loc env level ty = env, Pattern_type_clash(Errortrace.unification_error ~trace, None))) -type pattern_checking_mode = - | Normal - (** We are checking user code. *) - | Counter_example of counter_example_checking_info - (** In [Counter_example] mode, we are checking a counter-example - candidate produced by Parmatch. This is a syntactic pattern that - represents a set of values by using or-patterns (p_1 | ... | p_n) - to enumerate all alternatives in the counter-example - search. These or-patterns occur at every choice point, possibly - deep inside the pattern. - - Parmatch does not use type information, so this pattern may - exhibit two issues: - - some parts of the pattern may be ill-typed due to GADTs, and - - some wildcard patterns may not match any values: their type is - empty. - - The aim of [type_pat] in the [Counter_example] mode is to refine - this syntactic pattern into a well-typed pattern, and ensure - that it matches at least one concrete value. - - It filters ill-typed branches of or-patterns. - (see {!splitting_mode} below) - - It tries to check that wildcard patterns are non-empty. - (see {!explosion_fuel}) - *) - -and counter_example_checking_info = { - explosion_fuel: int; - splitting_mode: splitting_mode; - constrs: (string, Types.constructor_description) Hashtbl.t; - labels: (string, Types.label_description) Hashtbl.t; - } -(** - [explosion_fuel] controls the checking of wildcard patterns. We - eliminate potentially-empty wildcard patterns by exploding them - into concrete sub-patterns, for example (K1 _ | K2 _) or - { l1: _; l2: _ }. [explosion_fuel] is the depth limit on wildcard - explosion. Such depth limit is required to avoid non-termination - and compilation-time blowups. - - [splitting_mode] controls the handling of or-patterns. In - [Counter_example] mode, we only need to select one branch that - leads to a well-typed pattern. Checking all branches is expensive, - we use different search strategies (see {!splitting_mode}) to - reduce the number of explored alternatives. - - [constrs] and [labels] contain metadata produced by [Parmatch] to - type-check the given syntactic pattern. [Parmatch] produces - counter-examples by turning typed patterns into - [Parsetree.pattern]. In this process, constructor and label paths - are lost, and are replaced by generated strings. [constrs] and - [labels] map those synthetic names back to the typed descriptions - of the original names. - *) - -(** Due to GADT constraints, an or-pattern produced within - a counter-example may have ill-typed branches. Consider for example - - {[ - type _ tag = Int : int tag | Bool : bool tag - ]} - - then [Parmatch] will propose the or-pattern [Int | Bool] whenever - a pattern of type [tag] is required to form a counter-example. For - example, a function expects a (int tag option) and only [None] is - handled by the user-written pattern. [Some (Int | Bool)] is not - well-typed in this context, only the sub-pattern [Some Int] is. - In this example, the expected type coming from the context - suffices to know which or-pattern branch must be chosen. - - In the general case, choosing a branch can have non-local effects - on the typability of the term. For example, consider a tuple type - ['a tag * ...'a...], where the first component is a GADT. All - constructor choices for this GADT lead to a well-typed branch in - isolation (['a] is unconstrained), but choosing one of them adds - a constraint on ['a] that may make the other tuple elements - ill-typed. - - In general, after choosing each possible branch of the or-pattern, - [type_pat] has to check the rest of the pattern to tell if this - choice leads to a well-typed term. This may lead to an explosion - of typing/search work -- the rest of the term may in turn contain - alternatives. - - We use careful strategies to try to limit counterexample-checking - time; [splitting_mode] represents those strategies. -*) -and splitting_mode = - | Backtrack_or - (** Always backtrack in or-patterns. - - [Backtrack_or] selects a single alternative from an or-pattern - by using backtracking, trying to choose each branch in turn, and - to complete it into a valid sub-pattern. We call this - "splitting" the or-pattern. - - We use this mode when looking for unused patterns or sub-patterns, - in particular to check a refutation clause (p -> .). - *) - | Refine_or of { inside_nonsplit_or: bool; } - (** Only backtrack when needed. - - [Refine_or] tries another approach for refining or-pattern. - - Instead of always splitting each or-pattern, It first attempts to - find branches that do not introduce new constraints (because they - do not contain GADT constructors). Those branches are such that, - if they fail, all other branches will fail. - - If we find one such branch, we attempt to complete the subpattern - (checking what's outside the or-pattern), ignoring other - branches -- we never consider another branch choice again. If all - branches are constrained, it falls back to splitting the - or-pattern. - - We use this mode when checking exhaustivity of pattern matching. - *) - -(** This exception is only used internally within [type_pat_aux], in - counter-example mode, to jump back to the parent or-pattern in the - [Refine_or] strategy. - - Such a parent exists precisely when [inside_nonsplit_or = true]; - it's an invariant that we always setup an exception handler for - [Need_backtrack] when we set this flag. *) -exception Need_backtrack - -(** This exception is only used internally within [type_pat_aux], in - counter-example mode. We use it to discard counter-example candidates - that do not match any value. *) -exception Empty_branch - -type abort_reason = Adds_constraints | Empty - -(** Remember current typing state for backtracking. - No variable information, as we only backtrack on - patterns without variables (cf. assert statements). *) -type state = - { snapshot: snapshot; - levels: Ctype.levels; - env: Env.t; } -let save_state env = - { snapshot = Btype.snapshot (); - levels = Ctype.save_levels (); - env = !env; } -let set_state s env = - Btype.backtrack s.snapshot; - Ctype.set_levels s.levels; - env := s.env - -(** Find the first alternative in the tree of or-patterns for which - [f] does not raise an error. If all fail, the last error is - propagated *) -let rec find_valid_alternative f pat = - match pat.ppat_desc with - | Ppat_or(p1,p2) -> - (try find_valid_alternative f p1 with - | Empty_branch | Error _ -> find_valid_alternative f p2 - ) - | _ -> f pat - -let no_explosion = function - | Normal -> Normal - | Counter_example info -> - Counter_example { info with explosion_fuel = 0 } - -let get_splitting_mode = function - | Normal -> None - | Counter_example {splitting_mode} -> Some splitting_mode - -let enter_nonsplit_or mode = match mode with - | Normal -> Normal - | Counter_example info -> - let splitting_mode = match info.splitting_mode with - | Backtrack_or -> - (* in Backtrack_or mode, or-patterns are always split *) - assert false - | Refine_or _ -> - Refine_or {inside_nonsplit_or = true} - in Counter_example { info with splitting_mode } (** The typedtree has two distinct syntactic categories for patterns, "value" patterns, matching on values, and "computation" patterns @@ -1678,26 +1648,21 @@ let as_comp_pattern | Value -> as_computation_pattern pat | Computation -> pat -(* type_pat propagates the expected type. - Unification may update the typing environment. - - In counter-example mode, [Empty_branch] is raised when the counter-example - does not match any value. *) +(** [type_pat] propagates the expected type, and + unification may update the typing environment. *) let rec type_pat - : type k r . k pattern_category -> + : type k . type_pat_state -> k pattern_category -> no_existentials: existential_restriction option -> - mode: pattern_checking_mode -> env: Env.t ref -> Parsetree.pattern -> - type_expr -> (k general_pattern -> r) -> r - = fun category ~no_existentials ~mode - ~env sp expected_ty k -> + penv: Pattern_env.t -> Parsetree.pattern -> type_expr -> + k general_pattern + = fun tps category ~no_existentials ~penv sp expected_ty -> Msupport.with_saved_types ~warning_attribute:sp.ppat_attributes ?save_part:None (fun () -> let saved = save_levels () in try - type_pat_aux category ~no_existentials ~mode - ~env sp expected_ty k - with Error _ as exn when mode = Normal -> + type_pat_aux tps category ~no_existentials ~penv sp expected_ty + with Error _ as exn -> (* We only want to catch error, not internal exceptions such as [Need_backtrack], etc. *) Msupport.erroneous_type_register expected_ty; @@ -1710,149 +1675,113 @@ let rec type_pat pat_loc = loc; pat_extra = []; pat_type = expected_ty; - pat_env = !env; + pat_env = !!penv; pat_attributes = Msupport.recovery_attributes sp.ppat_attributes; } in - k (match category with + (match category with | Value -> pat | Computation -> as_computation_pattern pat) ) and type_pat_aux - : type k r . k pattern_category -> no_existentials:_ -> mode:_ -> - env:_ -> _ -> _ -> (k general_pattern -> r) -> r - = fun category ~no_existentials ~mode - ~env sp expected_ty k -> - let type_pat category ?(mode=mode) ?(env=env) = - type_pat category ~no_existentials ~mode ~env + : type k . type_pat_state -> k pattern_category -> no_existentials:_ -> + penv:Pattern_env.t -> _ -> _ -> k general_pattern + = fun tps category ~no_existentials ~penv sp expected_ty -> + let type_pat tps category ?(penv=penv) = + type_pat tps category ~no_existentials ~penv in let loc = sp.ppat_loc in - let refine = - match mode with Normal -> None | Counter_example _ -> Some true in let solve_expected (x : pattern) : pattern = - unify_pat ~refine env x (instance expected_ty); + unify_pat ~sdesc_for_hint:sp.ppat_desc !!penv x (instance expected_ty); x in - let rp x = - let crp (x : k general_pattern) : k general_pattern = - match category with - | Value -> rp x - | Computation -> rcp x in - if mode = Normal then crp x else x in - let rp k x = k (rp x) - and rvp k x = k (rp (pure category x)) - and rcp k x = k (rp (only_impure category x)) in - let construction_not_used_in_counterexamples = (mode = Normal) in - let must_backtrack_on_gadt = match get_splitting_mode mode with - | None -> false - | Some Backtrack_or -> false - | Some (Refine_or {inside_nonsplit_or}) -> inside_nonsplit_or + let crp (x : k general_pattern) : k general_pattern = + match category with + | Value -> rp x + | Computation -> rcp x in + (* record {general,value,computation} pattern *) + let rp = crp + and rvp x = crp (pure category x) + and rcp x = crp (only_impure category x) in match sp.ppat_desc with Ppat_any -> - let k' d = rvp k { - pat_desc = d; + rvp { + pat_desc = Tpat_any; pat_loc = loc; pat_extra=[]; pat_type = instance expected_ty; pat_attributes = sp.ppat_attributes; - pat_env = !env } - in - begin match mode with - | Normal -> k' Tpat_any - | Counter_example {explosion_fuel; _} when explosion_fuel <= 0 -> - k' Tpat_any - | Counter_example ({explosion_fuel; _} as info) -> - let open Parmatch in - begin match ppat_of_type !env expected_ty with - | PT_empty -> raise Empty_branch - | PT_any -> k' Tpat_any - | PT_pattern (explosion, sp, constrs, labels) -> - let explosion_fuel = - match explosion with - | PE_single -> explosion_fuel - 1 - | PE_gadt_cases -> - if must_backtrack_on_gadt then raise Need_backtrack; - explosion_fuel - 5 - in - let mode = - Counter_example { info with explosion_fuel; constrs; labels } - in - type_pat category ~mode sp expected_ty k - end - end + pat_env = !!penv } | Ppat_var name -> let ty = instance expected_ty in - let id = (* PR#7330 *) - if name.txt = "*extension*" then - Ident.create_local name.txt - else - enter_variable loc name ty sp.ppat_attributes - in - rvp k { - pat_desc = Tpat_var (id, name); + let id, uid = enter_variable tps loc name ty sp.ppat_attributes in + rvp { + pat_desc = Tpat_var (id, name, uid); pat_loc = loc; pat_extra=[]; pat_type = ty; pat_attributes = sp.ppat_attributes; - pat_env = !env } + pat_env = !!penv } | Ppat_unpack name -> - assert construction_not_used_in_counterexamples; let t = instance expected_ty in begin match name.txt with | None -> - rvp k { + rvp { pat_desc = Tpat_any; pat_loc = sp.ppat_loc; pat_extra=[Tpat_unpack, name.loc, sp.ppat_attributes]; pat_type = t; pat_attributes = []; - pat_env = !env } + pat_env = !!penv } | Some s -> let v = { name with txt = s } in - let id = enter_variable loc v t ~is_module:true sp.ppat_attributes in - rvp k { - pat_desc = Tpat_var (id, v); + (* We're able to pass ~is_module:true here without an error because + [Ppat_unpack] is a case identified by [may_contain_modules]. See + the comment on [may_contain_modules]. *) + let id, uid = + enter_variable tps loc v t ~is_module:true sp.ppat_attributes + in + rvp { + pat_desc = Tpat_var (id, v, uid); pat_loc = sp.ppat_loc; pat_extra=[Tpat_unpack, loc, sp.ppat_attributes]; pat_type = t; pat_attributes = []; - pat_env = !env } + pat_env = !!penv } end | Ppat_constraint( {ppat_desc=Ppat_var name; ppat_loc=lloc; ppat_attributes = attrs}, ({ptyp_desc=Ptyp_poly _} as sty)) -> (* explicitly polymorphic type *) - assert construction_not_used_in_counterexamples; let cty, ty, ty' = - solve_Ppat_poly_constraint ~refine env lloc sty expected_ty in - let id = enter_variable lloc name ty' attrs in - rvp k { pat_desc = Tpat_var (id, name); - pat_loc = lloc; - pat_extra = [Tpat_constraint cty, loc, sp.ppat_attributes]; - pat_type = ty; - pat_attributes = []; - pat_env = !env } + solve_Ppat_poly_constraint tps !!penv lloc sty expected_ty in + let id, uid = enter_variable tps lloc name ty' attrs in + rvp { pat_desc = Tpat_var (id, name, uid); + pat_loc = lloc; + pat_extra = [Tpat_constraint cty, loc, sp.ppat_attributes]; + pat_type = ty; + pat_attributes = []; + pat_env = !!penv } | Ppat_alias(sq, name) -> - assert construction_not_used_in_counterexamples; - type_pat Value sq expected_ty (fun q -> - let ty_var = solve_Ppat_alias ~refine env q in - let id = - enter_variable ~is_as_variable:true loc name ty_var sp.ppat_attributes - in - rvp k { - pat_desc = Tpat_alias(q, id, name); - pat_loc = loc; pat_extra=[]; - pat_type = q.pat_type; - pat_attributes = sp.ppat_attributes; - pat_env = !env }) + let q = type_pat tps Value sq expected_ty in + let ty_var = solve_Ppat_alias !!penv q in + let id, uid = + enter_variable + ~is_as_variable:true tps name.loc name ty_var sp.ppat_attributes + in + rvp { pat_desc = Tpat_alias(q, id, name, uid); + pat_loc = loc; pat_extra=[]; + pat_type = q.pat_type; + pat_attributes = sp.ppat_attributes; + pat_env = !!penv } | Ppat_constant cst -> - let cst = constant_or_raise !env loc cst in - rvp k @@ solve_expected { + let cst = constant_or_raise !!penv loc cst in + rvp @@ solve_expected { pat_desc = Tpat_constant cst; pat_loc = loc; pat_extra=[]; pat_type = type_constant cst; pat_attributes = sp.ppat_attributes; - pat_env = !env } + pat_env = !!penv } | Ppat_interval (Pconst_char c1, Pconst_char c2) -> let open Ast_helper.Pat in let gloc = {loc with Location.loc_ghost=true} in @@ -1865,54 +1794,45 @@ and type_pat_aux in let p = if c1 <= c2 then loop c1 c2 else loop c2 c1 in let p = {p with ppat_loc=loc} in - type_pat category ~mode:(no_explosion mode) p expected_ty k + type_pat tps category p expected_ty (* TODO: record 'extra' to remember about interval *) | Ppat_interval _ -> - raise (error (loc, !env, Invalid_interval)) + raise (error (loc, !!penv, Invalid_interval)) | Ppat_tuple spl -> assert (List.length spl >= 2); - let expected_tys = solve_Ppat_tuple ~refine loc env spl expected_ty in - let spl_ann = List.combine spl expected_tys in - map_fold_cont (fun (p,t) -> type_pat Value p t) spl_ann (fun pl -> - rvp k { + let expected_tys = + solve_Ppat_tuple ~refine:false loc penv spl expected_ty in + let pl = List.map2 (type_pat tps Value) spl expected_tys in + rvp { pat_desc = Tpat_tuple pl; pat_loc = loc; pat_extra=[]; pat_type = newty (Ttuple(List.map (fun p -> p.pat_type) pl)); pat_attributes = sp.ppat_attributes; - pat_env = !env }) + pat_env = !!penv } | Ppat_construct(lid, sarg) -> let expected_type = - match extract_concrete_variant !env expected_ty with + match extract_concrete_variant !!penv expected_ty with | Variant_type(p0, p, _) -> Some (p0, p, is_principal expected_ty) | Maybe_a_variant_type -> None | Not_a_variant_type -> let srt = wrong_kind_sort_of_constructor lid.txt in let err = Wrong_expected_kind(srt, Pattern, expected_ty) in - raise (error (loc, !env, err)) + raise (error (loc, !!penv, err)) in let constr = - match lid.txt, mode with - | Longident.Lident s, Counter_example {constrs; _} -> - (* assert: cf. {!counter_example_checking_info} documentation *) - assert (Hashtbl.mem constrs s); - Hashtbl.find constrs s - | _ -> let candidates = - Env.lookup_all_constructors Env.Pattern ~loc:lid.loc lid.txt !env in + Env.lookup_all_constructors Env.Pattern ~loc:lid.loc lid.txt !!penv in wrap_disambiguate "This variant pattern is expected to have" (mk_expected expected_ty) - (Constructor.disambiguate Env.Pattern lid !env expected_type) + (Constructor.disambiguate Env.Pattern lid !!penv expected_type) candidates in - if constr.cstr_generalized && must_backtrack_on_gadt then - raise Need_backtrack; begin match no_existentials, constr.cstr_existentials with | None, _ | _, [] -> () - | Some r, (_ :: _ as exs) -> - let exs = List.map (Ctype.existential_name constr) exs in + | Some r, (_ :: _) -> let name = constr.cstr_name in - raise (error (loc, !env, Unexpected_existential (r, name, exs))) + raise (error (loc, !!penv, Unexpected_existential (r, name))) end; let sarg', existential_styp = match sarg with @@ -1923,7 +1843,7 @@ and type_pat_aux | Some ([], sp) -> Some sp, None | Some (_, sp) -> - raise (error (sp.ppat_loc, !env, Missing_type_constraint)) + raise (error (sp.ppat_loc, !!penv, Missing_type_constraint)) in let sargs = match sarg' with @@ -1948,11 +1868,11 @@ and type_pat_aux | _ -> () end; if List.length sargs <> constr.cstr_arity then - raise(error(loc, !env, Constructor_arity_mismatch(lid.txt, + raise(error(loc, !!penv, Constructor_arity_mismatch(lid.txt, constr.cstr_arity, List.length sargs))); let (ty_args, existential_ctyp) = - solve_Ppat_construct ~refine env loc constr no_existentials + solve_Ppat_construct ~refine:false tps penv loc constr no_existentials existential_styp expected_ty in @@ -1964,7 +1884,7 @@ and type_pat_aux | Ppat_alias (p, _) -> check_non_escaping p | Ppat_constraint _ -> - raise (error (p.ppat_loc, !env, Inlined_record_escape)) + raise (error (p.ppat_loc, !!penv, Inlined_record_escape)) | _ -> () in @@ -1973,52 +1893,46 @@ and type_pat_aux Option.iter (fun (_, sarg) -> check_non_escaping sarg) sarg end; - map_fold_cont - (fun (p,t) -> type_pat Value p t) - (List.combine sargs ty_args) - (fun args -> - rvp k { - pat_desc=Tpat_construct(lid, constr, args, existential_ctyp); + let args = List.map2 (type_pat tps Value) sargs ty_args in + rvp { pat_desc=Tpat_construct(lid, constr, args, existential_ctyp); pat_loc = loc; pat_extra=[]; pat_type = instance expected_ty; pat_attributes = sp.ppat_attributes; - pat_env = !env }) + pat_env = !!penv } | Ppat_variant(tag, sarg) -> - if tag = Parmatch.some_private_tag then - assert (match mode with Normal -> false | Counter_example _ -> true); + assert (tag <> Parmatch.some_private_tag); let constant = (sarg = None) in let arg_type, row, pat_type = - solve_Ppat_variant ~refine loc env tag constant expected_ty in - let k arg = - rvp k { + solve_Ppat_variant ~refine:false loc penv tag constant expected_ty in + let arg = + (* PR#6235: propagate type information *) + match sarg, arg_type with + Some sp, [ty] -> Some (type_pat tps Value sp ty) + | _ -> None + in + rvp { pat_desc = Tpat_variant(tag, arg, ref row); pat_loc = loc; pat_extra = []; pat_type = pat_type; pat_attributes = sp.ppat_attributes; - pat_env = !env } - in begin - (* PR#6235: propagate type information *) - match sarg, arg_type with - Some p, [ty] -> type_pat Value p ty (fun p -> k (Some p)) - | _ -> k None - end + pat_env = !!penv } | Ppat_record(lid_sp_list, closed) -> assert (lid_sp_list <> []); let expected_type, record_ty = - match extract_concrete_record !env expected_ty with + match extract_concrete_record !!penv expected_ty with | Record_type(p0, p, _) -> let ty = generic_instance expected_ty in Some (p0, p, is_principal expected_ty), ty | Maybe_a_record_type -> None, newvar () | Not_a_record_type -> let err = Wrong_expected_kind(Record, Pattern, expected_ty) in - raise (error (loc, !env, err)) + raise (error (loc, !!penv, err)) in - let type_label_pat (label_lid, label, sarg) k = + let type_label_pat (label_lid, label, sarg) = let ty_arg = - solve_Ppat_record_field ~refine loc env label label_lid record_ty in - type_pat Value sarg ty_arg (fun arg -> - k (label_lid, label, arg)) + solve_Ppat_record_field ~refine:false loc penv label label_lid + record_ty in + (label_lid, label, type_pat tps Value sarg ty_arg) in let make_record_pat lbl_pat_list = check_recordpat_labels loc lbl_pat_list closed; @@ -2027,286 +1941,240 @@ and type_pat_aux pat_loc = loc; pat_extra=[]; pat_type = instance record_ty; pat_attributes = sp.ppat_attributes; - pat_env = !env; + pat_env = !!penv; } in - let k' pat = rvp k @@ solve_expected pat in - begin match mode with - | Normal -> - k' (wrap_disambiguate "This record pattern is expected to have" - (mk_expected expected_ty) - (type_label_a_list loc false !env Env.Projection - type_label_pat expected_type lid_sp_list) - make_record_pat) - | Counter_example {labels; _} -> - type_label_a_list ~labels loc false !env Env.Projection - type_label_pat expected_type lid_sp_list - (fun lbl_pat_list -> k' (make_record_pat lbl_pat_list)) - end + let lbl_a_list = + wrap_disambiguate "This record pattern is expected to have" + (mk_expected expected_ty) + (type_label_a_list loc false !!penv Env.Projection + type_label_pat expected_type) + lid_sp_list + in + rvp @@ solve_expected (make_record_pat lbl_a_list) | Ppat_array spl -> - let ty_elt = solve_Ppat_array ~refine loc env expected_ty in - map_fold_cont (fun p -> type_pat Value p ty_elt) spl (fun pl -> - rvp k { + let ty_elt = solve_Ppat_array ~refine:false loc penv expected_ty in + let pl = List.map (fun p -> type_pat tps Value p ty_elt) spl in + rvp { pat_desc = Tpat_array pl; pat_loc = loc; pat_extra=[]; pat_type = instance expected_ty; pat_attributes = sp.ppat_attributes; - pat_env = !env }) + pat_env = !!penv } | Ppat_or(sp1, sp2) -> - begin match mode with - | Normal -> - let initial_pattern_variables = !pattern_variables in - let initial_module_variables = !module_variables in - let equation_level = !gadt_equations_level in - let outter_lev = get_current_level () in - (* introduce a new scope *) - begin_def (); - let lev = get_current_level () in - gadt_equations_level := Some lev; - let type_pat_rec env sp = - type_pat category sp expected_ty ~env (fun x -> x) in - let env1 = ref !env in - let p1 = type_pat_rec env1 sp1 in - let p1_variables = !pattern_variables in - let p1_module_variables = !module_variables in - pattern_variables := initial_pattern_variables; - module_variables := initial_module_variables; - let env2 = ref !env in - let p2 = type_pat_rec env2 sp2 in - end_def (); - gadt_equations_level := equation_level; - let p2_variables = !pattern_variables in - (* Make sure no variable with an ambiguous type gets added to the - environment. *) - List.iter (fun { pv_type; pv_loc; _ } -> - check_scope_escape pv_loc !env1 outter_lev pv_type - ) p1_variables; - List.iter (fun { pv_type; pv_loc; _ } -> - check_scope_escape pv_loc !env2 outter_lev pv_type - ) p2_variables; - let alpha_env = - enter_orpat_variables loc !env p1_variables p2_variables in - let p2 = alpha_pat alpha_env p2 in - pattern_variables := p1_variables; - module_variables := p1_module_variables; - rp k { pat_desc = Tpat_or (p1, p2, None); - pat_loc = loc; pat_extra = []; - pat_type = instance expected_ty; - pat_attributes = sp.ppat_attributes; - pat_env = !env } - | Counter_example {splitting_mode; _} -> - (* We are in counter-example mode, but try to avoid backtracking *) - let must_split = - match splitting_mode with - | Backtrack_or -> true - | Refine_or _ -> false in - let state = save_state env in - let split_or sp = - let typ pat = type_pat category pat expected_ty k in - find_valid_alternative (fun pat -> set_state state env; typ pat) sp - in - if must_split then split_or sp else - let type_pat_result env sp : (_, abort_reason) result = - let mode = enter_nonsplit_or mode in - match type_pat category ~mode sp expected_ty ~env (fun x -> x) with - | res -> Ok res - | exception Need_backtrack -> Error Adds_constraints - | exception Empty_branch -> Error Empty + (* Reset pattern forces for just [tps2] because later we append [tps1] and + [tps2]'s pattern forces, and we don't want to duplicate [tps]'s pattern + forces. *) + let tps1 = copy_type_pat_state tps in + let tps2 = {(copy_type_pat_state tps) with tps_pattern_force = []} in + (* Introduce a new scope using with_local_level without generalizations *) + let env1, p1, env2, p2 = + with_local_level begin fun () -> + let type_pat_rec tps penv sp = + type_pat tps category sp expected_ty ~penv in - let p1 = type_pat_result (ref !env) sp1 in - let p2 = type_pat_result (ref !env) sp2 in - match p1, p2 with - | Error Empty, Error Empty -> - raise Empty_branch - | Error Adds_constraints, Error _ - | Error _, Error Adds_constraints -> - let inside_nonsplit_or = - match splitting_mode with - | Backtrack_or -> false - | Refine_or {inside_nonsplit_or} -> inside_nonsplit_or in - if inside_nonsplit_or - then raise Need_backtrack - else split_or sp - | Ok p, Error _ - | Error _, Ok p -> - rp k p - | Ok p1, Ok p2 -> - rp k { pat_desc = Tpat_or (p1, p2, None); - pat_loc = loc; pat_extra = []; - pat_type = instance expected_ty; - pat_attributes = sp.ppat_attributes; - pat_env = !env } - end + let penv1 = + Pattern_env.copy ~equations_scope:(get_current_level ()) penv in + let penv2 = Pattern_env.copy penv1 in + let p1 = type_pat_rec tps1 penv1 sp1 in + let p2 = type_pat_rec tps2 penv2 sp2 in + (penv1.env, p1, penv2.env, p2) + end + in + let p1_variables = tps1.tps_pattern_variables in + let p2_variables = tps2.tps_pattern_variables in + (* Make sure no variable with an ambiguous type gets added to the + environment. *) + let outer_lev = get_current_level () in + List.iter (fun { pv_type; pv_loc; _ } -> + check_scope_escape pv_loc env1 outer_lev pv_type + ) p1_variables; + List.iter (fun { pv_type; pv_loc; _ } -> + check_scope_escape pv_loc env2 outer_lev pv_type + ) p2_variables; + let alpha_env = + enter_orpat_variables loc !!penv p1_variables p2_variables in + (* Propagate the outcome of checking the or-pattern back to + the type_pat_state that the caller passed in. + *) + blit_type_pat_state + ~src: + { tps_pattern_variables = tps1.tps_pattern_variables; + (* We want to propagate all pattern forces, regardless of + which branch they were found in. + *) + tps_pattern_force = + tps2.tps_pattern_force @ tps1.tps_pattern_force; + tps_module_variables = tps1.tps_module_variables; + } + ~dst:tps; + let p2 = alpha_pat alpha_env p2 in + rp { pat_desc = Tpat_or (p1, p2, None); + pat_loc = loc; pat_extra = []; + pat_type = instance expected_ty; + pat_attributes = sp.ppat_attributes; + pat_env = !!penv } | Ppat_lazy sp1 -> - let nv = solve_Ppat_lazy ~refine loc env expected_ty in - (* do not explode under lazy: PR#7421 *) - type_pat Value ~mode:(no_explosion mode) sp1 nv (fun p1 -> - rvp k { + let nv = solve_Ppat_lazy ~refine:false loc penv expected_ty in + let p1 = type_pat tps Value sp1 nv in + rvp { pat_desc = Tpat_lazy p1; pat_loc = loc; pat_extra=[]; pat_type = instance expected_ty; pat_attributes = sp.ppat_attributes; - pat_env = !env }) + pat_env = !!penv } | Ppat_constraint(sp, sty) -> - assert construction_not_used_in_counterexamples; (* Pretend separate = true *) let cty, ty, expected_ty' = - solve_Ppat_constraint ~refine loc env sty expected_ty in - type_pat category sp expected_ty' (fun p -> - (*Format.printf "%a@.%a@." - Printtyp.raw_type_expr ty - Printtyp.raw_type_expr p.pat_type;*) - let extra = (Tpat_constraint cty, loc, sp.ppat_attributes) in - let p : k general_pattern = - match category, (p : k general_pattern) with - | Value, {pat_desc = Tpat_var (id,s); _} -> - {p with - pat_type = ty; - pat_desc = + solve_Ppat_constraint tps loc !!penv sty expected_ty in + let p = type_pat tps category sp expected_ty' in + let extra = (Tpat_constraint cty, loc, sp.ppat_attributes) in + begin match category, (p : k general_pattern) with + | Value, {pat_desc = Tpat_var (id,s,uid); _} -> + { p with + pat_type = ty; + pat_desc = Tpat_alias - ({p with pat_desc = Tpat_any; pat_attributes = []}, id,s); - pat_extra = [extra]; - } - | _, p -> - { p with pat_type = ty; pat_extra = extra::p.pat_extra } - in k p) + ({p with + pat_desc = Tpat_any; + pat_attributes = (* Merlin should ignore these nodes *) + [Ast_helper.Attr.mk (mknoloc "merlin.hide") (PStr [])]; + pat_loc = { p.pat_loc with loc_ghost = true }}, id,s,uid); + pat_extra = [extra]; + } + | _, p -> + { p with pat_type = ty; pat_extra = extra::p.pat_extra } + end | Ppat_type lid -> - assert construction_not_used_in_counterexamples; - let (path, p) = build_or_pat !env loc lid in - k @@ pure category @@ solve_expected + let (path, p) = build_or_pat !!penv loc lid in + pure category @@ solve_expected { p with pat_extra = (Tpat_type (path, lid), loc, sp.ppat_attributes) :: p.pat_extra } | Ppat_open (lid,p) -> - assert construction_not_used_in_counterexamples; let path, new_env = - !type_open Asttypes.Fresh !env sp.ppat_loc lid in - env := new_env; - type_pat category ~env p expected_ty ( fun p -> - let new_env = !env in - begin match Env.remove_last_open path new_env with - | None -> assert false - | Some closed_env -> env := closed_env - end; - k { p with pat_extra = (Tpat_open (path,lid,new_env), + !type_open Asttypes.Fresh !!penv sp.ppat_loc lid in + Pattern_env.set_env penv new_env; + let p = type_pat tps category ~penv p expected_ty in + let new_env = !!penv in + begin match Env.remove_last_open path new_env with + | None -> assert false + | Some closed_env -> Pattern_env.set_env penv closed_env + end; + { p with pat_extra = (Tpat_open (path,lid,new_env), loc, sp.ppat_attributes) :: p.pat_extra } - ) | Ppat_exception p -> - type_pat Value p Predef.type_exn (fun p_exn -> - rcp k { + let p_exn = type_pat tps Value p Predef.type_exn in + rcp { pat_desc = Tpat_exception p_exn; pat_loc = sp.ppat_loc; pat_extra = []; pat_type = expected_ty; - pat_env = !env; + pat_env = !!penv; pat_attributes = sp.ppat_attributes; - }) + } | Ppat_extension ext -> raise (Error_forward (Builtin_attributes.error_of_extension ext)) -let type_pat category ?no_existentials ?(mode=Normal) - ?(lev=get_current_level()) env sp expected_ty = - Misc.protect_refs [Misc.R (gadt_equations_level, Some lev)] (fun () -> - type_pat category ~no_existentials ~mode - ~env sp expected_ty (fun x -> x) - ) +let iter_pattern_variables_type f : pattern_variable list -> unit = + List.iter (fun {pv_type; _} -> f pv_type) -(* this function is passed to Partial.parmatch - to type check gadt nonexhaustiveness *) -let partial_pred ~lev ~splitting_mode ?(explode=0) - env expected_ty constrs labels p = - let env = ref env in - let state = save_state env in - let mode = - Counter_example { - splitting_mode; - explosion_fuel = explode; - constrs; labels; - } in - try - reset_pattern true; - let typed_p = type_pat Value ~lev ~mode env p expected_ty in - set_state state env; - (* types are invalidated but we don't need them here *) - Some typed_p - with Error _ | Empty_branch -> - set_state state env; - None +let add_pattern_variables ?check ?check_as env pv = + List.fold_right + (fun {pv_id; pv_type; pv_loc; pv_as_var; pv_attributes; pv_uid} env -> + let check = if pv_as_var then check_as else check in + Env.add_value ?check pv_id + {val_type = pv_type; val_kind = Val_reg; Types.val_loc = pv_loc; + val_attributes = pv_attributes; + val_uid = pv_uid; + } env + ) + pv env -let check_partial ?(lev=get_current_level ()) env expected_ty loc cases = - let explode = match cases with [_] -> 5 | _ -> 0 in - let splitting_mode = Refine_or {inside_nonsplit_or = false} in - Parmatch.check_partial - (partial_pred ~lev ~splitting_mode ~explode env expected_ty) loc cases - -let check_unused ?(lev=get_current_level ()) env expected_ty cases = - Parmatch.check_unused - (fun refute constrs labels spat -> - match - partial_pred ~lev ~splitting_mode:Backtrack_or ~explode:5 - env expected_ty constrs labels spat - with - Some pat when refute -> - raise_error (error (spat.ppat_loc, env, Unrefuted_pattern pat)); - Some pat - | r -> r) - cases - -let iter_pattern_variables_type f : pattern_variable list -> unit = - List.iter (fun {pv_type; _} -> f pv_type) - -let add_pattern_variables ?check ?check_as env pv = - List.fold_right - (fun {pv_id; pv_type; pv_loc; pv_as_var; pv_attributes} env -> - let check = if pv_as_var then check_as else check in - Env.add_value ?check pv_id - {val_type = pv_type; val_kind = Val_reg; Types.val_loc = pv_loc; - val_attributes = pv_attributes; - val_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); - } env - ) - pv env - -let type_pattern category ~lev env spat expected_ty = - reset_pattern true; - let new_env = ref env in - let pat = type_pat category ~lev new_env spat expected_ty in - let pvs = get_ref pattern_variables in - let unpacks = get_ref module_variables in - (pat, !new_env, get_ref pattern_force, pvs, unpacks) +let add_module_variables env module_variables = + let module_variables_as_list = + match module_variables with + | Modvars_allowed mvs -> mvs.module_variables + | Modvars_ignored | Modvars_rejected -> [] + in + List.fold_left (fun env { mv_id; mv_loc; mv_name; mv_uid } -> + Typetexp.TyVarEnv.with_local_scope begin fun () -> + (* This code is parallel to the typing of Pexp_letmodule. However we + omit the call to [Mtype.lower_nongen] as it's not necessary here. + For Pexp_letmodule, the call to [type_module] is done in a raised + level and so needs to be modified to have the correct, outer level. + Here, on the other hand, we're calling [type_module] outside the + raised level, so there's no extra step to take. + *) + let modl, md_shape = + !type_module env + Ast_helper.( + Mod.unpack ~loc:mv_loc + (Exp.ident ~loc:mv_name.loc + (mkloc (Longident.Lident mv_name.txt) + mv_name.loc))) + in + let pres = + match modl.mod_type with + | Mty_alias _ -> Mp_absent + | _ -> Mp_present + in + let md = + { md_type = modl.mod_type; md_attributes = []; + md_loc = mv_name.loc; + md_uid = mv_uid; } + in + Env.add_module_declaration ~shape:md_shape ~check:true mv_id pres md env + end + ) env module_variables_as_list + +let type_pat tps category ?no_existentials penv = + type_pat tps category ~no_existentials ~penv + +let type_pattern category ~lev env spat expected_ty allow_modules = + let tps = create_type_pat_state allow_modules in + let new_penv = Pattern_env.make env + ~equations_scope:lev ~allow_recursive_equations:false in + let pat = type_pat tps category new_penv spat expected_ty in + let { tps_pattern_variables = pvs; + tps_module_variables = mvs; + tps_pattern_force = pattern_forces; + } = tps in + (pat, !!new_penv, pattern_forces, pvs, mvs) let type_pattern_list - category no_existentials env spatl expected_tys allow + category no_existentials env spatl expected_tys allow_modules = - reset_pattern allow; - let new_env = ref env in + let tps = create_type_pat_state allow_modules in + let equations_scope = get_current_level () in + let new_penv = Pattern_env.make env + ~equations_scope ~allow_recursive_equations:false in let type_pat (attrs, pat) ty = Builtin_attributes.warning_scope ~ppwarning:false attrs (fun () -> - type_pat category ~no_existentials new_env pat ty + type_pat tps category ~no_existentials new_penv pat ty ) in let patl = List.map2 type_pat spatl expected_tys in - let pvs = get_ref pattern_variables in - let unpacks = - List.map (fun (name, loc) -> - {tu_name = name; tu_loc = loc; - tu_uid = Uid.mk ~current_unit:(Env.get_unit_name ())} - ) (get_ref module_variables) - in - let new_env = add_pattern_variables !new_env pvs in - (patl, new_env, get_ref pattern_force, pvs, unpacks) + let { tps_pattern_variables = pvs; + tps_module_variables = mvs; + tps_pattern_force = pattern_forces; + } = tps in + (patl, !!new_penv, pattern_forces, pvs, mvs) let type_class_arg_pattern cl_num val_env met_env l spat = - reset_pattern false; + let tps = create_type_pat_state Modules_rejected in let nv = newvar () in + let equations_scope = get_current_level () in + let new_penv = Pattern_env.make val_env + ~equations_scope ~allow_recursive_equations:false in let pat = - type_pat Value ~no_existentials:In_class_args (ref val_env) spat nv in + type_pat tps Value ~no_existentials:In_class_args new_penv spat nv in if has_variants pat then begin Parmatch.pressure_variants val_env [pat]; finalize_variants pat; end; - List.iter (fun f -> f()) (get_ref pattern_force); - if is_optional l then unify_pat (ref val_env) pat (type_option (newvar ())); + List.iter (fun f -> f()) tps.tps_pattern_force; + if is_optional l then unify_pat val_env pat (type_option (newvar ())); let (pv, val_env, met_env) = List.fold_right (fun {pv_id; pv_type; pv_loc; pv_as_var; pv_attributes} @@ -2337,24 +2205,370 @@ let type_class_arg_pattern cl_num val_env met_env l spat = met_env in ((id', pv_id, pv_type)::pv, val_env, met_env)) - !pattern_variables ([], val_env, met_env) + tps.tps_pattern_variables ([], val_env, met_env) in (pat, pv, val_env, met_env) let type_self_pattern env spat = let open Ast_helper in let spat = Pat.mk(Ppat_alias (spat, mknoloc "selfpat-*")) in - reset_pattern false; + let tps = create_type_pat_state Modules_rejected in let nv = newvar() in + let equations_scope = get_current_level () in + let new_penv = Pattern_env.make env + ~equations_scope ~allow_recursive_equations:false in let pat = - type_pat Value ~no_existentials:In_self_pattern (ref env) spat nv in - List.iter (fun f -> f()) (get_ref pattern_force); - let pv = !pattern_variables in - pattern_variables := []; - pat, pv + type_pat tps Value ~no_existentials:In_self_pattern new_penv spat nv in + List.iter (fun f -> f()) tps.tps_pattern_force; + pat, tps.tps_pattern_variables type delayed_check = ((unit -> unit) * Warnings.state) + +(** In [check_counter_example_pat], we will check a counter-example candidate + produced by Parmatch. This is a pattern that represents a set of values by + using or-patterns (p_1 | ... | p_n) to enumerate all alternatives in the + counter-example search. These or-patterns occur at every choice point, + possibly deep inside the pattern. + + Parmatch does not use type information, so this pattern may + exhibit two issues: + - some parts of the pattern may be ill-typed due to GADTs, and + - some wildcard patterns may not match any values: their type is + empty. + + The aim of [check_counter_example_pat] is to refine this untyped pattern + into a well-typed pattern, and ensure that it matches at least one + concrete value. + - It filters ill-typed branches of or-patterns. + (see {!splitting_mode} below) + - It tries to check that wildcard patterns are non-empty. + (see {!explosion_fuel}) + *) + +type counter_example_checking_info = { + explosion_fuel: int; + splitting_mode: splitting_mode; + } +(** + [explosion_fuel] controls the checking of wildcard patterns. We + eliminate potentially-empty wildcard patterns by exploding them + into concrete sub-patterns, for example (K1 _ | K2 _) or + { l1: _; l2: _ }. [explosion_fuel] is the depth limit on wildcard + explosion. Such depth limit is required to avoid non-termination + and compilation-time blowups. + + [splitting_mode] controls the handling of or-patterns. In + [Counter_example] mode, we only need to select one branch that + leads to a well-typed pattern. Checking all branches is expensive, + we use different search strategies (see {!splitting_mode}) to + reduce the number of explored alternatives. + *) + +(** Due to GADT constraints, an or-pattern produced within + a counter-example may have ill-typed branches. Consider for example + + {[ + type _ tag = Int : int tag | Bool : bool tag + ]} + + then [Parmatch] will propose the or-pattern [Int | Bool] whenever + a pattern of type [tag] is required to form a counter-example. For + example, a function expects a (int tag option) and only [None] is + handled by the user-written pattern. [Some (Int | Bool)] is not + well-typed in this context, only the sub-pattern [Some Int] is. + In this example, the expected type coming from the context + suffices to know which or-pattern branch must be chosen. + + In the general case, choosing a branch can have non-local effects + on the typability of the term. For example, consider a tuple type + ['a tag * ...'a...], where the first component is a GADT. All + constructor choices for this GADT lead to a well-typed branch in + isolation (['a] is unconstrained), but choosing one of them adds + a constraint on ['a] that may make the other tuple elements + ill-typed. + + In general, after choosing each possible branch of the or-pattern, + [check_counter_example_pat] has to check the rest of the pattern to + tell if this choice leads to a well-typed term. This may lead to an + explosion of typing/search work -- the rest of the term may in turn + contain alternatives. + + We use careful strategies to try to limit counterexample-checking + time; [splitting_mode] represents those strategies. +*) +and splitting_mode = + | Backtrack_or + (** Always backtrack in or-patterns. + + [Backtrack_or] selects a single alternative from an or-pattern + by using backtracking, trying to choose each branch in turn, and + to complete it into a valid sub-pattern. We call this + "splitting" the or-pattern. + + We use this mode when looking for unused patterns or sub-patterns, + in particular to check a refutation clause (p -> .). + *) + | Refine_or of { inside_nonsplit_or: bool; } + (** Only backtrack when needed. + + [Refine_or] tries another approach for refining or-pattern. + + Instead of always splitting each or-pattern, It first attempts to + find branches that do not introduce new constraints (because they + do not contain GADT constructors). Those branches are such that, + if they fail, all other branches will fail. + + If we find one such branch, we attempt to complete the subpattern + (checking what's outside the or-pattern), ignoring other + branches -- we never consider another branch choice again. If all + branches are constrained, it falls back to splitting the + or-pattern. + + We use this mode when checking exhaustivity of pattern matching. + *) + +(** This exception is only used internally within [check_counter_example_pat], + to jump back to the parent or-pattern in the [Refine_or] strategy. + + Such a parent exists precisely when [inside_nonsplit_or = true]; + it's an invariant that we always setup an exception handler for + [Need_backtrack] when we set this flag. *) +exception Need_backtrack + +(** This exception is only used internally within [check_counter_example_pat]. + We use it to discard counter-example candidates that do not match any + value. *) +exception Empty_branch + +type abort_reason = Adds_constraints | Empty + +(** Remember current typing state for backtracking. + No variable information, as we only backtrack on + patterns without variables (cf. assert statements). + In the GADT mode, [env] may be extended by unification, + and therefore it needs to be saved along with a [snapshot]. *) +type unification_state = + { snapshot: snapshot; + env: Env.t; } +let save_state penv = + { snapshot = Btype.snapshot (); + env = !!penv; } +let set_state s penv = + Btype.backtrack s.snapshot; + Pattern_env.set_env penv s.env + +(** Find the first alternative in the tree of or-patterns for which + [f] does not raise an error. If all fail, the last error is + propagated *) +let rec find_valid_alternative f pat = + match pat.pat_desc with + | Tpat_or(p1,p2,_) -> + (try find_valid_alternative f p1 with + | Empty_branch | Error _ -> find_valid_alternative f p2 + ) + | _ -> f pat + +let no_explosion info = { info with explosion_fuel = 0 } + +let enter_nonsplit_or info = + let splitting_mode = match info.splitting_mode with + | Backtrack_or -> + (* in Backtrack_or mode, or-patterns are always split *) + assert false + | Refine_or _ -> + Refine_or {inside_nonsplit_or = true} + in { info with splitting_mode } + +let rec check_counter_example_pat + ~info ~(penv : Pattern_env.t) type_pat_state tp expected_ty k = + let check_rec ?(info=info) ?(penv=penv) = + check_counter_example_pat ~info ~penv type_pat_state in + let loc = tp.pat_loc in + let refine = true in + let solve_expected (x : pattern) : pattern = + unify_pat_types_refine ~refine x.pat_loc penv x.pat_type + (instance expected_ty); + x + in + (* "make pattern" and "make pattern then continue" *) + let mp ?(pat_type = expected_ty) desc = + { pat_desc = desc; pat_loc = loc; pat_extra=[]; + pat_type = instance pat_type; pat_attributes = []; pat_env = !!penv } in + let mkp k ?pat_type desc = k (mp ?pat_type desc) in + let must_backtrack_on_gadt = + match info.splitting_mode with + | Backtrack_or -> false + | Refine_or {inside_nonsplit_or} -> inside_nonsplit_or + in + match tp.pat_desc with + Tpat_any | Tpat_var _ -> + let k' () = mkp k tp.pat_desc in + if info.explosion_fuel <= 0 then k' () else + let decrease n = {info with explosion_fuel = info.explosion_fuel - n} in + begin match Parmatch.pats_of_type !!penv expected_ty with + | [] -> raise Empty_branch + | [{pat_desc = Tpat_any}] -> k' () + | [tp] -> check_rec ~info:(decrease 1) tp expected_ty k + | tp :: tpl -> + if must_backtrack_on_gadt then raise Need_backtrack; + let tp = + List.fold_left + (fun tp tp' -> {tp with pat_desc = Tpat_or (tp, tp', None)}) + tp tpl + in + check_rec ~info:(decrease 5) tp expected_ty k + end + | Tpat_alias (p, _, _, _) -> check_rec ~info p expected_ty k + | Tpat_constant cst -> + let cst = constant_or_raise !!penv loc (Untypeast.constant cst) in + k @@ solve_expected (mp (Tpat_constant cst) ~pat_type:(type_constant cst)) + | Tpat_tuple tpl -> + assert (List.length tpl >= 2); + let expected_tys = solve_Ppat_tuple ~refine loc penv tpl expected_ty in + let tpl_ann = List.combine tpl expected_tys in + map_fold_cont (fun (p,t) -> check_rec p t) tpl_ann (fun pl -> + mkp k (Tpat_tuple pl) + ~pat_type:(newty (Ttuple(List.map (fun p -> p.pat_type) pl)))) + | Tpat_construct(cstr_lid, constr, targs, _) -> + if constr.cstr_generalized && must_backtrack_on_gadt then + raise Need_backtrack; + let (ty_args, existential_ctyp) = + solve_Ppat_construct + ~refine type_pat_state penv loc constr None None expected_ty + in + map_fold_cont + (fun (p,t) -> check_rec p t) + (List.combine targs ty_args) + (fun args -> + mkp k (Tpat_construct(cstr_lid, constr, args, existential_ctyp))) + | Tpat_variant(tag, targ, _) -> + let constant = (targ = None) in + let arg_type, row, pat_type = + solve_Ppat_variant ~refine loc penv tag constant expected_ty in + let k arg = + mkp k ~pat_type (Tpat_variant(tag, arg, ref row)) + in begin + (* PR#6235: propagate type information *) + match targ, arg_type with + Some p, [ty] -> check_rec p ty (fun p -> k (Some p)) + | _ -> k None + end + | Tpat_record(fields, closed) -> + let record_ty = generic_instance expected_ty in + let type_label_pat (label_lid, label, targ) k = + let ty_arg = + solve_Ppat_record_field ~refine loc penv label label_lid record_ty in + check_rec targ ty_arg (fun arg -> k (label_lid, label, arg)) + in + map_fold_cont type_label_pat fields + (fun fields -> mkp k (Tpat_record (fields, closed))) + | Tpat_array tpl -> + let ty_elt = solve_Ppat_array ~refine loc penv expected_ty in + map_fold_cont (fun p -> check_rec p ty_elt) tpl + (fun pl -> mkp k (Tpat_array pl)) + | Tpat_or(tp1, tp2, _) -> + (* We are in counter-example mode, but try to avoid backtracking *) + let must_split = + match info.splitting_mode with + | Backtrack_or -> true + | Refine_or _ -> false in + let state = save_state penv in + let split_or tp = + let type_alternative pat = + set_state state penv; check_rec pat expected_ty k in + find_valid_alternative type_alternative tp + in + if must_split then split_or tp else + let check_rec_result penv tp : (_, abort_reason) result = + let info = enter_nonsplit_or info in + match check_rec ~info tp expected_ty ~penv (fun x -> x) with + | res -> Ok res + | exception Need_backtrack -> Error Adds_constraints + | exception Empty_branch -> Error Empty + in + let p1 = check_rec_result (Pattern_env.copy penv) tp1 in + let p2 = check_rec_result (Pattern_env.copy penv) tp2 in + begin match p1, p2 with + | Error Empty, Error Empty -> + raise Empty_branch + | Error Adds_constraints, Error _ + | Error _, Error Adds_constraints -> + let inside_nonsplit_or = + match info.splitting_mode with + | Backtrack_or -> false + | Refine_or {inside_nonsplit_or} -> inside_nonsplit_or in + if inside_nonsplit_or + then raise Need_backtrack + else split_or tp + | Ok p, Error _ + | Error _, Ok p -> + k p + | Ok p1, Ok p2 -> + mkp k (Tpat_or (p1, p2, None)) + end + | Tpat_lazy tp1 -> + let nv = solve_Ppat_lazy ~refine loc penv expected_ty in + (* do not explode under lazy: PR#7421 *) + check_rec ~info:(no_explosion info) tp1 nv + (fun p1 -> mkp k (Tpat_lazy p1)) + +let check_counter_example_pat ~counter_example_args penv tp expected_ty = + (* [check_counter_example_pat] doesn't use [type_pat_state] in an interesting + way -- one of the functions it calls writes an entry into + [tps_pattern_forces] -- so we can just ignore module patterns. *) + let type_pat_state = create_type_pat_state Modules_ignored in + check_counter_example_pat + ~info:counter_example_args ~penv type_pat_state tp expected_ty (fun x -> x) + +(* this function is passed to Partial.parmatch + to type check gadt nonexhaustiveness *) +let partial_pred ~lev ~splitting_mode ?(explode=0) env expected_ty p = + let penv = Pattern_env.make env + ~equations_scope:lev ~allow_recursive_equations:true in + let state = save_state penv in + let counter_example_args = + { + splitting_mode; + explosion_fuel = explode; + } in + try + let typed_p = + check_counter_example_pat ~counter_example_args penv p expected_ty + in + set_state state penv; + (* types are invalidated but we don't need them here *) + Some typed_p + with Error _ | Empty_branch -> + set_state state penv; + None + +let check_partial + ?(lev=get_current_level ()) env expected_ty loc cases + = + let explode = match cases with [_] -> 5 | _ -> 0 in + let splitting_mode = Refine_or {inside_nonsplit_or = false} in + Parmatch.check_partial + (partial_pred ~lev ~splitting_mode ~explode env expected_ty) + loc cases + +let check_unused + ?(lev=get_current_level ()) env expected_ty cases + = + Parmatch.check_unused + (fun refute pat -> + match + partial_pred ~lev ~splitting_mode:Backtrack_or ~explode:5 + env expected_ty pat + with + Some pat' when refute -> + raise_error (error (pat.pat_loc, env, Unrefuted_pattern pat')); + Some pat + | r -> r) + cases + +(** Some delayed checks, to be executed after typing the whole + compilation unit or toplevel phrase *) let delayed_checks = ref [] let reset_delayed_checks () = delayed_checks := [] let add_delayed_check f = @@ -2463,7 +2677,7 @@ let rec is_nonexpansive exp = equivalent to (raise e; diverge), and a nonexpansive "diverge" can be produced using lazy values or the relaxed value restriction. See GPR#1142 *) - | Texp_assert exp -> + | Texp_assert (exp, _) -> is_nonexpansive exp | Texp_apply ( { exp_desc = Texp_ident (_, _, {val_kind = @@ -2519,7 +2733,7 @@ and is_nonexpansive_mod mexp = | Tstr_attribute _ -> true ) str.str_items - | Tmod_apply _ -> false + | Tmod_apply _ | Tmod_apply_unit _ -> false and is_nonexpansive_opt = function | None -> true @@ -2527,19 +2741,21 @@ and is_nonexpansive_opt = function let maybe_expansive e = not (is_nonexpansive e) -let check_recursive_bindings env valbinds = +let annotate_recursive_bindings env valbinds = let ids = let_bound_idents valbinds in - List.iter - (fun {vb_expr} -> - if not (Rec_check.is_valid_recursive_expression ids vb_expr) then + List.map + (fun {vb_pat; vb_expr; vb_rec_kind = _; vb_attributes; vb_loc} -> + match (Value_rec_check.is_valid_recursive_expression ids vb_expr) with + | None -> raise(error(vb_expr.exp_loc, env, Illegal_letrec_expr)) - ) + | Some vb_rec_kind -> + { vb_pat; vb_expr; vb_rec_kind; vb_attributes; vb_loc}) valbinds let check_recursive_class_bindings env ids exprs = List.iter (fun expr -> - if not (Rec_check.is_valid_class_expr ids expr) then + if not (Value_rec_check.is_valid_class_expr ids expr) then raise(error(expr.cl_loc, env, Illegal_class_expr))) exprs @@ -2568,14 +2784,55 @@ let rec approx_type env sty = approx_type env sty | _ -> newvar () +let type_pattern_approx env spat = + match spat.ppat_desc with + | Ppat_constraint (_, sty) -> approx_type env sty + | _ -> newvar () + +let type_approx_fun env label default spat ret_ty = + let ty = type_pattern_approx env spat in + let ty = + match label, default with + | (Nolabel | Labelled _), _ -> ty + | Optional _, None -> + unify_pat_types spat.ppat_loc env ty (type_option (newvar ())); + ty + | Optional _, Some _ -> + type_option ty + in + newty (Tarrow (label, ty, ret_ty, commu_ok)) + +let type_approx_constraint env ty constraint_ ~loc = + match constraint_ with + | Pconstraint constrain -> + let ty_constrain = approx_type env constrain in + begin try unify env ty ty_constrain with Unify err -> + raise (error (loc, env, Expr_type_clash (err, None, None))) + end; + ty_constrain + | Pcoerce (constrain, coerce) -> + let approx_ty_opt = function + | None -> newvar () + | Some sty -> approx_type env sty + in + let ty_constrain = approx_ty_opt constrain + and ty_coerce = approx_type env coerce in + begin try unify env ty ty_constrain with Unify err -> + raise (error (loc, env, Expr_type_clash (err, None, None))) + end; + ty_coerce + +let type_approx_constraint_opt env ty constraint_ ~loc = + match constraint_ with + | None -> ty + | Some constraint_ -> type_approx_constraint env ty constraint_ ~loc + let rec type_approx env sexp = + let loc = sexp.pexp_loc in match sexp.pexp_desc with Pexp_let (_, _, e) -> type_approx env e - | Pexp_fun (p, _, _, e) -> - let ty = if is_optional p then type_option (newvar ()) else newvar () in - newty (Tarrow(p, ty, type_approx env e, commu_ok)) - | Pexp_function ({pc_rhs=e}::_) -> - newty (Tarrow(Nolabel, newvar (), type_approx env e, commu_ok)) + | Pexp_function (params, c, body) -> + type_approx_function env params c body ~loc | Pexp_match (_, {pc_rhs=e}::_) -> type_approx env e | Pexp_try (e, _) -> type_approx env e | Pexp_tuple l -> newty (Ttuple(List.map (type_approx env) l)) @@ -2583,25 +2840,34 @@ let rec type_approx env sexp = | Pexp_sequence (_,e) -> type_approx env e | Pexp_constraint (e, sty) -> let ty = type_approx env e in - let ty1 = approx_type env sty in - begin try unify env ty ty1 with Unify err -> - raise(error(sexp.pexp_loc, env, Expr_type_clash (err, None, None))) - end; - ty1 + type_approx_constraint env ty (Pconstraint sty) ~loc | Pexp_coerce (e, sty1, sty2) -> - let approx_ty_opt = function - | None -> newvar () - | Some sty -> approx_type env sty - in - let ty = type_approx env e - and ty1 = approx_ty_opt sty1 - and ty2 = approx_type env sty2 in - begin try unify env ty ty1 with Unify err -> - raise(error(sexp.pexp_loc, env, Expr_type_clash (err, None, None))) - end; - ty2 + let ty = type_approx env e in + type_approx_constraint env ty (Pcoerce (sty1, sty2)) ~loc | _ -> newvar () +and type_approx_function env params c body ~loc = + (* We can approximate types up to the first newtype parameter, whereupon + we give up. + *) + match params with + | { pparam_desc = Pparam_val (label, default, pat) } :: params -> + type_approx_fun env label default pat + (type_approx_function env params c body ~loc) + | { pparam_desc = Pparam_newtype _ } :: _ -> + newvar () + | [] -> + let body_ty = + match body with + | Pfunction_body body -> + type_approx env body + | Pfunction_cases ({pc_rhs = e} :: _, _, _) -> + newty (Tarrow (Nolabel, newvar (), type_approx env e, commu_ok)) + | Pfunction_cases ([], _, _) -> + newvar () + in + type_approx_constraint_opt env body_ty c ~loc + (* List labels in a function type, and whether return type is a variable *) let rec list_labels_aux env visited ls ty_fun = let ty = expand_head env ty_fun in @@ -2620,22 +2886,20 @@ let list_labels env ty = ty_expected should already be generalized. *) let check_univars env kind exp ty_expected vars = let pty = instance ty_expected in - begin_def (); let exp_ty, vars = - match get_desc pty with - Tpoly (body, tl) -> - (* Enforce scoping for type_let: - since body is not generic, instance_poly only makes - copies of nodes that have a Tvar as descendant *) - let _, ty' = instance_poly true tl body in - let vars, exp_ty = instance_parameterized_type vars exp.exp_type in - unify_exp_types exp.exp_loc env exp_ty ty'; - exp_ty, vars - | _ -> assert false + with_local_level_iter ~post:generalize begin fun () -> + match get_desc pty with + Tpoly (body, tl) -> + (* Enforce scoping for type_let: + since body is not generic, instance_poly only makes + copies of nodes that have a Tunivar as descendant *) + let _, ty' = instance_poly ~fixed:true tl body in + let vars, exp_ty = instance_parameterized_type vars exp.exp_type in + unify_exp_types exp.exp_loc env exp_ty ty'; + ((exp_ty, vars), exp_ty::vars) + | _ -> assert false + end in - end_def (); - generalize exp_ty; - List.iter generalize vars; let ty, complete = polyfy env exp_ty vars in if not complete then let ty_expected = instance ty_expected in @@ -2692,14 +2956,14 @@ let check_statement exp = If [exp] has a function type, we check that it is not syntactically the result of a function application, as this is often a bug in certain contexts (eg the rhs of a let-binding or in the argument of [ignore]). For example, - [ignore (List.map print_int)] written by mistake instad of [ignore (List.map + [ignore (List.map print_int)] written by mistake instead of [ignore (List.map print_int li)]. The check can be disabled by explicitly annotating the expression with a type constraint, eg [(e : _ -> _)]. If [statement] is [true] and the [ignored-partial-application] is {em not} - triggered, then the [non-unit-statement] check is performaed (see + triggered, then the [non-unit-statement] check is performed (see [check_statement]). If the type of [exp] is not known at the time this function is called, the @@ -2755,6 +3019,19 @@ let check_partial_application ~statement exp = | _ -> doit () +let pattern_needs_partial_application_check p = + let rec check : type a. a general_pattern -> bool = fun p -> + not (List.exists (function (Tpat_constraint _, _, _) -> true | _ -> false) + p.pat_extra) && + match p.pat_desc with + | Tpat_any -> true + | Tpat_exception _ -> true + | Tpat_or (p1, p2, _) -> check p1 && check p2 + | Tpat_value p -> check (p :> value general_pattern) + | _ -> false + in + check p + (* Check that a type is generalizable at some level *) let generalizable level ty = let rec check ty = @@ -2838,6 +3115,22 @@ let may_contain_gadts p = | _ -> false) p +(* There are various things that we need to do in presence of module patterns + that aren't required if there are none. Most notably, we need to ensure the + modules are entered at the appropriate scope. The caller should use + [may_contain_modules] as an indication to set up the proper scope handling + code (via [allow_modules]) to permit module patterns. + The class of patterns identified here should stay in sync with the patterns + whose typing involves [enter_variable ~is_module:true], as these calls + will error if the scope handling isn't set up. +*) +let may_contain_modules p = + exists_ppat + (function + | {ppat_desc = Ppat_unpack _} -> true + | _ -> false) + p + let check_absent_variant env = iter_general_pattern { f = fun (type k) (pat : k general_pattern) -> match pat.pat_desc with @@ -2854,8 +3147,8 @@ let check_absent_variant env = create_row ~fields ~more:(newvar ()) ~closed:false ~fixed:None ~name:None in (* Should fail *) - unify_pat (ref env) {pat with pat_type = newty (Tvariant row')} - (correct_levels pat.pat_type) + unify_pat env {pat with pat_type = newty (Tvariant row')} + (correct_levels pat.pat_type) | _ -> () } (* Getting proper location of already typed expressions. @@ -2885,8 +3178,8 @@ let rec name_pattern default = function [] -> Ident.create_local default | p :: rem -> match p.pat_desc with - Tpat_var (id, _) -> id - | Tpat_alias(_, id, _) -> id + Tpat_var (id, _, _) -> id + | Tpat_alias(_, id, _, _) -> id | _ -> name_pattern default rem let name_cases default lst = @@ -2894,12 +3187,14 @@ let name_cases default lst = (* Typing of expressions *) -let unify_exp env exp expected_ty = +(** [sdesc_for_hint] is used by error messages to report literals in their + original formatting *) +let unify_exp ?sdesc_for_hint env exp expected_ty = let loc = proper_exp_loc exp in try unify_exp_types loc env exp.exp_type expected_ty with Error(loc, env, Expr_type_clash(err, tfc, None)) -> - raise (Error(loc, env, Expr_type_clash(err, tfc, Some exp.exp_desc))) + raise (error(loc, env, Expr_type_clash(err, tfc, sdesc_for_hint))) (* If [is_inferred e] is true, [e] will be typechecked without using the "expected type" provided by the context. *) @@ -2948,7 +3243,75 @@ let with_explanation explanation f = with Error (loc', env', Expr_type_clash(err', None, exp')) when not loc'.Location.loc_ghost -> let err = Expr_type_clash(err', Some explanation, exp') in - raise (Error (loc', env', err)) + raise (error (loc', env', err)) + +(* Generalize expressions *) +let generalize_structure_exp exp = generalize_structure exp.exp_type +let may_lower_contravariant_then_generalize env exp = + if maybe_expansive exp then lower_contravariant env exp.exp_type; + generalize exp.exp_type + +(* value binding elaboration *) + +let vb_exp_constraint {pvb_expr=expr; pvb_pat=pat; pvb_constraint=ct; _ } = + let open Ast_helper in + match ct with + | None -> expr + | Some (Pvc_constraint { locally_abstract_univars=[]; typ }) -> + begin match typ.ptyp_desc with + | Ptyp_poly _ -> expr + | _ -> + let loc = { expr.pexp_loc with Location.loc_ghost = true } in + Exp.constraint_ ~loc expr typ + end + | Some (Pvc_coercion { ground; coercion}) -> + let loc = { expr.pexp_loc with Location.loc_ghost = true } in + Exp.coerce ~loc expr ground coercion + | Some (Pvc_constraint { locally_abstract_univars=vars;typ}) -> + let loc_start = pat.ppat_loc.Location.loc_start in + let loc = { expr.pexp_loc with loc_start; loc_ghost=true } in + let expr = Exp.constraint_ ~loc expr typ in + List.fold_right (Exp.newtype ~loc) vars expr + +let vb_pat_constraint ({pvb_pat=pat; pvb_expr = exp; _ } as vb) = + vb.pvb_attributes, + let open Ast_helper in + match vb.pvb_constraint, pat.ppat_desc, exp.pexp_desc with + | Some (Pvc_constraint {locally_abstract_univars=[]; typ} + | Pvc_coercion { coercion=typ; _ }), + _, _ -> + Pat.constraint_ ~loc:{pat.ppat_loc with Location.loc_ghost=true} pat typ + | Some (Pvc_constraint {locally_abstract_univars=vars; typ }), _, _ -> + let varified = Typ.varify_constructors vars typ in + let t = Typ.poly ~loc:typ.ptyp_loc vars varified in + let loc_end = typ.ptyp_loc.Location.loc_end in + let loc = { pat.ppat_loc with loc_end; loc_ghost=true } in + Pat.constraint_ ~loc pat t + | None, (Ppat_any | Ppat_constraint _), _ -> pat + | None, _, Pexp_coerce (_, _, sty) + | None, _, Pexp_constraint (_, sty) when !Clflags.principal -> + (* propagate type annotation to pattern, + to allow it to be generalized in -principal mode *) + Pat.constraint_ ~loc:{pat.ppat_loc with Location.loc_ghost=true} pat sty + | _ -> pat + +(** The body of a constraint or coercion. The "body" may be either an expression + or a list of function cases. This type is polymorphic in the data returned + out of typing so that typing an expression body can return an expression + and typing a function cases body can return the cases. +*) +type 'ret constraint_arg = + { type_without_constraint: Env.t -> 'ret * type_expr; + (** [type_without_constraint] types a body (e :> t) where there is no + constraint. + *) + type_with_constraint: Env.t -> type_expr -> 'ret; + (** [type_with_constraint] types a body (e : t) or (e : t :> t') in + the presence of a constraint. + *) + is_self: 'ret -> bool; + (** Whether the thing being constrained is a [Val_self] ident. *) + } let rec type_exp ?recarg env sexp = (* We now delegate everything to type_expect *) @@ -2957,16 +3320,17 @@ let rec type_exp ?recarg env sexp = (* Typing of an expression with an expected type. This provide better error messages, and allows controlled propagation of return type information. - In the principal case, [type_expected'] may be at generic_level. + In the principal case, structural nodes of [type_expected_explained] may be + at [generic_level] (but its variables no higher than [!current_level]). *) -and type_expect ?in_function ?recarg env sexp ty_expected_explained = +and type_expect ?recarg env sexp ty_expected_explained = Msupport.with_saved_types ~warning_attribute:sexp.pexp_attributes ?save_part:None (fun () -> let saved = save_levels () in try - type_expect_ ?in_function ?recarg env sexp ty_expected_explained + type_expect_ ?recarg env sexp ty_expected_explained with exn -> Msupport.erroneous_type_register ty_expected_explained.ty; raise_error exn; @@ -2991,18 +3355,20 @@ and type_expect ?in_function ?recarg env sexp ty_expected_explained = }) and type_expect_ - ?in_function ?(recarg=Rejected) + ?(recarg=Rejected) env sexp ty_expected_explained = let { ty = ty_expected; explanation } = ty_expected_explained in let loc = sexp.pexp_loc in + let desc = sexp.pexp_desc in (* Record the expression type before unifying it with the expected type *) let with_explanation = with_explanation explanation in + (* Unify the result with [ty_expected], enforcing the current level *) let rue exp = with_explanation (fun () -> - unify_exp env (re exp) (instance ty_expected)); + unify_exp ~sdesc_for_hint:desc env (re exp) (instance ty_expected)); exp in - match sexp.pexp_desc with + match desc with | Pexp_ident lid -> let path, desc = type_ident env ~recarg lid in let exp_desc = @@ -3032,7 +3398,7 @@ and type_expect_ | Pexp_constant(Pconst_string (str, _, _) as cst) -> ( let cst = constant_or_raise env loc cst in (* Terrible hack for format strings *) - let ty_exp = expand_head env ty_expected in + let ty_exp = expand_head env (protect_expansion env ty_expected) in let fmt6_path = Path.(Pdot (Pident (Ident.create_persistent "CamlinternalFormatBasics"), "format6")) @@ -3048,7 +3414,7 @@ and type_expect_ if is_format then let format_parsetree = { (type_format loc str env) with pexp_loc = sexp.pexp_loc } in - type_expect ?in_function env format_parsetree ty_expected_explained + type_expect env format_parsetree ty_expected_explained else rue { exp_desc = Texp_constant cst; @@ -3066,10 +3432,11 @@ and type_expect_ exp_attributes = sexp.pexp_attributes; exp_env = env } | Pexp_let(Nonrecursive, - [{pvb_pat=spat; pvb_expr=sval; pvb_attributes=[]}], sbody) + [{pvb_pat=spat; pvb_attributes=[]; _ } as vb], sbody) when may_contain_gadts spat -> - (* TODO: allow non-empty attributes? *) - type_expect ?in_function env + (* TODO: allow non-empty attributes? *) + let sval = vb_exp_constraint vb in + type_expect env {sexp with pexp_desc = Pexp_match (sval, [Ast_helper.Exp.case spat sbody])} ty_expected_explained @@ -3078,61 +3445,125 @@ and type_expect_ if rec_flag = Recursive then In_rec else if List.compare_length_with spat_sexp_list 1 > 0 then In_group else With_attributes in - let (pat_exp_list, new_env, unpacks) = - type_let existential_context env rec_flag spat_sexp_list true in - let body = type_unpacks new_env unpacks sbody ty_expected_explained in - let () = - if rec_flag = Recursive then - check_recursive_bindings env pat_exp_list - in - re { - exp_desc = Texp_let(rec_flag, pat_exp_list, body); - exp_loc = loc; exp_extra = []; - exp_type = body.exp_type; - exp_attributes = sexp.pexp_attributes; - exp_env = env } - | Pexp_fun (l, Some default, spat, sbody) -> - assert(is_optional l); (* default allowed only with optional argument *) - let open Ast_helper in - let default_loc = default.pexp_loc in - let scases = [ - Exp.case - (Pat.construct ~loc:default_loc - (mknoloc (Longident.(Ldot (Lident "*predef*", "Some")))) - (Some ([], Pat.var ~loc:default_loc (mknoloc "*sth*")))) - (Exp.ident ~loc:default_loc (mknoloc (Longident.Lident "*sth*"))); - - Exp.case - (Pat.construct ~loc:default_loc - (mknoloc (Longident.(Ldot (Lident "*predef*", "None")))) - None) - default; - ] - in - let sloc = - { Location.loc_start = spat.ppat_loc.Location.loc_start; - loc_end = default_loc.Location.loc_end; - loc_ghost = true } + let may_contain_modules = + List.exists (fun pvb -> may_contain_modules pvb.pvb_pat) spat_sexp_list in - let smatch = - Exp.match_ ~loc:sloc - (Exp.ident ~loc (mknoloc (Longident.Lident "*opt*"))) - scases + let outer_level = get_current_level () in + let (pat_exp_list, body, _new_env) = + (* If the patterns contain module unpacks, there is a possibility that + the types of the let body or bound expressions mention types + introduced by those unpacks. The below code checks for scope escape + via both of these pathways (body, bound expressions). + *) + with_local_level_if may_contain_modules begin fun () -> + let allow_modules = + if may_contain_modules + then + let scope = create_scope () in + Modules_allowed { scope } + else Modules_rejected + in + let (pat_exp_list, new_env) = + type_let existential_context env rec_flag spat_sexp_list + allow_modules + in + let body = type_expect new_env sbody ty_expected_explained in + let pat_exp_list = match rec_flag with + | Recursive -> annotate_recursive_bindings env pat_exp_list + | Nonrecursive -> pat_exp_list + in + (* The "bound expressions" component of the scope escape check. + + This kind of scope escape is relevant only for recursive + module definitions. + *) + if rec_flag = Recursive && may_contain_modules then begin + List.iter + (fun vb -> + (* [type_let] already generalized bound expressions' types + in-place. We first take an instance before checking scope + escape at the outer level to avoid losing generality of + types added to [new_env]. + *) + let bound_exp = vb.vb_expr in + generalize_structure_exp bound_exp; + let bound_exp_type = Ctype.instance bound_exp.exp_type in + let loc = proper_exp_loc bound_exp in + let outer_var = newvar2 outer_level in + (* Checking unification within an environment extended with the + module bindings allows us to correctly accept more programs. + This environment allows unification to identify more cases + where a type introduced by the module is equal to a type + introduced at an outer scope. *) + unify_exp_types loc new_env bound_exp_type outer_var) + pat_exp_list + end; + (pat_exp_list, body, new_env) + end + ~post:(fun (_pat_exp_list, body, new_env) -> + (* The "body" component of the scope escape check. *) + unify_exp new_env body (newvar ())) in - let pat = Pat.var ~loc:sloc (mknoloc "*opt*") in - let body = - Exp.let_ ~loc Nonrecursive - ~attrs:[Attr.mk (mknoloc "#default") (PStr [])] - [Vb.mk spat smatch] sbody + re { + exp_desc = Texp_let(rec_flag, pat_exp_list, body); + exp_loc = loc; exp_extra = []; + exp_type = body.exp_type; + exp_attributes = sexp.pexp_attributes; + exp_env = env } + | Pexp_function (params, body_constraint, body) -> + let in_function = ty_expected_explained, loc in + let exp_type, params, body, newtypes, contains_gadt = + type_function env params body_constraint body ty_expected ~in_function + ~first:true in - type_function ?in_function loc sexp.pexp_attributes env - ty_expected_explained l [Exp.case pat body] - | Pexp_fun (l, None, spat, sbody) -> - type_function ?in_function loc sexp.pexp_attributes env - ty_expected_explained l [Ast_helper.Exp.case spat sbody] - | Pexp_function caselist -> - type_function ?in_function - loc sexp.pexp_attributes env ty_expected_explained Nolabel caselist + (* Require that the n-ary function is known to have at least n arrows + in the type. This prevents GADT equations introduced by the parameters + from hiding arrows from the resulting type. + + Performance hack: Only do this check when any of [params] contains a + GADT, as this is the only opportunity for arrows to be hidden from the + resulting type. + *) + begin match contains_gadt with + | No_gadt -> () + | Contains_gadt -> + let ty_function = + List.fold_right + (fun param rest_ty -> + newty + (Tarrow (param.fp_arg_label, newvar (), rest_ty, commu_ok))) + params + (match body with + | Tfunction_body _ -> newvar () + | Tfunction_cases _ -> + newty (Tarrow (Nolabel, newvar (), newvar (), commu_ok))) + in + try unify env ty_function exp_type + with Unify trace -> + let syntactic_arity = + List.length params + + (match body with + | Tfunction_body _ -> 0 + | Tfunction_cases _ -> 1) + in + let err = + Function_arity_type_clash + { syntactic_arity; + type_constraint = exp_type; + trace; + } + in + raise (Error (loc, env, err)) + end; + re + { exp_desc = Texp_function (params, body); + exp_loc = loc; + exp_extra = List.map (fun (id, txt_loc, uid) -> + Texp_newtype' (id, txt_loc, uid), txt_loc.loc, []) newtypes; + exp_type; + exp_attributes = sexp.pexp_attributes; + exp_env = env; + } | Pexp_apply(sfunct, sargs) -> assert (sargs <> []); let rec lower_args seen ty_fun = @@ -3140,23 +3571,23 @@ and type_expect_ if TypeSet.mem ty seen then () else match get_desc ty with Tarrow (_l, ty_arg, ty_fun, _com) -> - (try unify_var env (newvar()) ty_arg + (try enforce_current_level env ty_arg with Unify _ -> assert false); lower_args (TypeSet.add ty seen) ty_fun | _ -> () in let type_sfunct sfunct = - begin_def (); (* one more level for non-returning functions *) - if !Clflags.principal then begin_def (); - let funct = type_exp env sfunct in - if !Clflags.principal then begin - end_def (); - generalize_structure funct.exp_type - end; - let ty = instance funct.exp_type in - end_def (); - wrap_trace_gadt_instances env (lower_args TypeSet.empty) ty; - funct + (* one more level for warning on non-returning functions *) + with_local_level_iter + begin fun () -> + let funct = + with_local_level_if_principal (fun () -> type_exp env sfunct) + ~post: generalize_structure_exp + in + let ty = instance funct.exp_type in + (funct, [ty]) + end + ~post:(wrap_trace_gadt_instances env (lower_args TypeSet.empty)) in let funct, sargs = let funct = type_sfunct sfunct in @@ -3175,31 +3606,26 @@ and type_expect_ | _ -> funct, sargs in - begin_def (); let (args, ty_res) = type_application env funct sargs in - end_def (); - unify_var env (newvar()) funct.exp_type; - let exp = - { exp_desc = Texp_apply(funct, args); - exp_loc = loc; exp_extra = []; - exp_type = ty_res; - exp_attributes = sexp.pexp_attributes; - exp_env = env } in - begin - try rue exp - with Error (_, _, Expr_type_clash _) as err -> - Misc.reraise_preserving_backtrace err (fun () -> - check_partial_application ~statement:false exp) - end + rue { + exp_desc = Texp_apply(funct, args); + exp_loc = loc; exp_extra = []; + exp_type = ty_res; + exp_attributes = sexp.pexp_attributes; + exp_env = env } | Pexp_match(sarg, caselist) -> - begin_def (); - let arg = type_exp env sarg in - end_def (); - if maybe_expansive arg then lower_contravariant env arg.exp_type; - generalize arg.exp_type; + let arg = + with_local_level (fun () -> type_exp env sarg) + ~post:(may_lower_contravariant_then_generalize env) + in let cases, partial = type_cases Computation env - arg.exp_type ty_expected_explained true loc caselist in + arg.exp_type ty_expected_explained + ~check_if_total:true loc caselist in + if + List.for_all (fun c -> pattern_needs_partial_application_check c.c_lhs) + cases + then check_partial_application ~statement:false arg; re { exp_desc = Texp_match(arg, cases, partial); exp_loc = loc; exp_extra = []; @@ -3210,7 +3636,8 @@ and type_expect_ let body = type_expect env sbody ty_expected_explained in let cases, _ = type_cases Value env - Predef.type_exn ty_expected_explained false loc caselist in + Predef.type_exn ty_expected_explained + ~check_if_total:false loc caselist in re { exp_desc = Texp_try(body, cases); exp_loc = loc; exp_extra = []; @@ -3238,9 +3665,10 @@ and type_expect_ type_construct env loc lid sarg ty_expected_explained sexp.pexp_attributes | Pexp_variant(l, sarg) -> (* Keep sharing *) + let ty_expected1 = protect_expansion env ty_expected in let ty_expected0 = instance ty_expected in begin try match - sarg, get_desc (expand_head env ty_expected), + sarg, get_desc (expand_head env ty_expected1), get_desc (expand_head env ty_expected0) with | Some sarg, Tvariant row, Tvariant row0 -> @@ -3284,12 +3712,11 @@ and type_expect_ match opt_sexp with None -> None | Some sexp -> - if !Clflags.principal then begin_def (); - let exp = type_exp ~recarg env sexp in - if !Clflags.principal then begin - end_def (); - generalize_structure exp.exp_type - end; + let exp = + with_local_level_if_principal + (fun () -> type_exp ~recarg env sexp) + ~post: generalize_structure_exp + in Some exp in let ty_record, expected_type = @@ -3320,10 +3747,10 @@ and type_expect_ | Some(_, _, true), Some _ -> ty_expected, expected_opath | (None | Some (_, _, false)), Some (_, p', _) -> let decl = Env.find_type p' env in - begin_def (); - let ty = newconstr p' (instance_list decl.type_params) in - end_def (); - generalize_structure ty; + let ty = + with_local_level ~post:generalize_structure + (fun () -> newconstr p' (instance_list decl.type_params)) + in ty, opt_exp_opath in let closed = (opt_sexp = None) in @@ -3331,9 +3758,9 @@ and type_expect_ wrap_disambiguate "This record expression is expected to have" (mk_expected ty_record) (type_label_a_list loc closed env Env.Construct - (fun e k -> k (type_label_exp true env loc ty_record e)) - expected_type lid_sexp_list) - (fun x -> x) + (type_label_exp true env loc ty_record) + expected_type) + lid_sexp_list in with_explanation (fun () -> unify_exp_types loc env (instance ty_record) (instance ty_expected)); @@ -3383,18 +3810,18 @@ and type_expect_ | Some exp -> let ty_exp = instance exp.exp_type in let unify_kept lbl = - let _, ty_arg1, ty_res1 = instance_label false lbl in + let _, ty_arg1, ty_res1 = instance_label ~fixed:false lbl in unify_exp_types exp.exp_loc env ty_exp ty_res1; match matching_label lbl with | lid, _lbl, lbl_exp -> (* do not connect result types for overridden labels *) Overridden (lid, lbl_exp) | exception Not_found -> begin - let _, ty_arg2, ty_res2 = instance_label false lbl in + let _, ty_arg2, ty_res2 = instance_label ~fixed:false lbl in unify_exp_types loc env ty_arg1 ty_arg2; with_explanation (fun () -> unify_exp_types loc env (instance ty_expected) ty_res2); - Kept ty_arg1 + Kept (ty_arg1, lbl.lbl_mut) end in let label_definitions = Array.map unify_kept lbl.lbl_all in @@ -3439,7 +3866,7 @@ and type_expect_ let (record, label, _) = type_label_access env srecord Env.Projection lid in - let (_, ty_arg, ty_res) = instance_label false label in + let (_, ty_arg, ty_res) = instance_label ~fixed:false label in unify_exp env record ty_res; rue { exp_desc = Texp_field(record, lid, label); @@ -3514,11 +3941,16 @@ and type_expect_ | Pexp_while(scond, sbody) -> let cond = type_expect env scond (mk_expected ~explanation:While_loop_conditional Predef.type_bool) in + let exp_type = + match cond.exp_desc with + | Texp_construct(_, {cstr_name="true"}, _) -> instance ty_expected + | _ -> instance Predef.type_unit + in let body = type_statement ~explanation:While_loop_body env sbody in rue { exp_desc = Texp_while(cond, body); exp_loc = loc; exp_extra = []; - exp_type = instance Predef.type_unit; + exp_type; exp_attributes = sexp.pexp_attributes; exp_env = env } | Pexp_for(param, slow, shigh, dir, sbody) -> @@ -3549,92 +3981,20 @@ and type_expect_ exp_attributes = sexp.pexp_attributes; exp_env = env } | Pexp_constraint (sarg, sty) -> - (* Pretend separate = true, 1% slowdown for lablgtk *) - begin_def (); - let cty = Typetexp.transl_simple_type env false sty in - let ty = cty.ctyp_type in - end_def (); - generalize_structure ty; - let (arg, ty') = (type_argument env sarg ty (instance ty), instance ty) in + let (ty, exp_extra) = type_constraint env sty in + let arg = type_argument env sarg ty (instance ty) in rue { exp_desc = arg.exp_desc; exp_loc = arg.exp_loc; - exp_type = ty'; + exp_type = instance ty; exp_attributes = arg.exp_attributes; exp_env = env; - exp_extra = - (Texp_constraint cty, loc, sexp.pexp_attributes) :: arg.exp_extra; + exp_extra = (exp_extra, loc, sexp.pexp_attributes) :: arg.exp_extra; } | Pexp_coerce(sarg, sty, sty') -> - (* Pretend separate = true, 1% slowdown for lablgtk *) - (* Also see PR#7199 for a problem with the following: - let separate = !Clflags.principal || Env.has_local_constraints env in*) - let (arg, ty',cty,cty') = - match sty with - | None -> - let (cty', ty', force) = - Typetexp.transl_simple_type_delayed env sty' - in - begin_def (); - let arg = type_exp env sarg in - end_def (); - let tv = newvar () in - let gen = generalizable (get_level tv) arg.exp_type in - unify_var env tv arg.exp_type; - begin match arg.exp_desc, !self_coercion, get_desc ty' with - Texp_ident(_, _, {val_kind=Val_self _}), (path,r) :: _, - Tconstr(path',_,_) when Path.same path path' -> - (* prerr_endline "self coercion"; *) - r := loc :: !r; - force () - | _ when free_variables ~env arg.exp_type = [] - && free_variables ~env ty' = [] -> - if not gen && (* first try a single coercion *) - let snap = snapshot () in - let ty, _b = enlarge_type env ty' in - try - force (); Ctype.unify env arg.exp_type ty; true - with Unify _ -> - backtrack snap; false - then () - else begin try - let force' = subtype env arg.exp_type ty' in - force (); force' (); - if not gen && !Clflags.principal then - Location.prerr_warning loc - (Warnings.Not_principal "this ground coercion"); - with Subtype err -> - (* prerr_endline "coercion failed"; *) - raise(error(loc, env, Not_subtype err)) - end; - | _ -> - let ty, b = enlarge_type env ty' in - force (); - begin try Ctype.unify env arg.exp_type ty with Unify err -> - let expanded = full_expand ~may_forget_scope:true env ty' in - raise(error(sarg.pexp_loc, env, - Coercion_failure({ty = ty'; expanded}, err, b))) - end - end; - (arg, ty', None, cty') - | Some sty -> - begin_def (); - let (cty, ty, force) = - Typetexp.transl_simple_type_delayed env sty - and (cty', ty', force') = - Typetexp.transl_simple_type_delayed env sty' - in - end_def (); - generalize_structure ty; - generalize_structure ty'; - begin try - let force'' = subtype env (instance ty) (instance ty') in - force (); force' (); force'' () - with Subtype err -> - raise(error(loc, env, Not_subtype err)) - end; - (type_argument env sarg ty (instance ty), - instance ty', Some cty, cty') + let arg, ty', exp_extra = + type_coerce (expression_constraint sarg) env loc sty sty' + ~loc_arg:sarg.pexp_loc in rue { exp_desc = arg.exp_desc; @@ -3642,99 +4002,16 @@ and type_expect_ exp_type = ty'; exp_attributes = arg.exp_attributes; exp_env = env; - exp_extra = (Texp_coerce (cty, cty'), loc, sexp.pexp_attributes) :: - arg.exp_extra; + exp_extra = (exp_extra, loc, sexp.pexp_attributes) :: arg.exp_extra; } | Pexp_send (e, {txt=met}) -> - if !Clflags.principal then begin_def (); - let obj = type_exp env e in - let obj_meths = ref None in - begin try - let (meth, typ) = - match obj.exp_desc with - | Texp_ident(_, _, {val_kind = Val_self(sign, meths, _, _)}) -> - let id, typ = - match meths with - | Self_concrete meths -> - obj_meths := Some meths; - let id = - match Meths.find met meths with - | id -> id - | exception Not_found -> - let valid_methods = - Meths.fold (fun lab _ acc -> lab :: acc) meths [] - in - raise (error(e.pexp_loc, env, - Undefined_self_method (met, valid_methods))) - in - let typ = Btype.method_type met sign in - id, typ - | Self_virtual meths_ref -> begin - obj_meths := Some !meths_ref; - match Meths.find met !meths_ref with - | id -> id, Btype.method_type met sign - | exception Not_found -> - let id = Ident.create_local met in - let ty = newvar () in - meths_ref := Meths.add met id !meths_ref; - add_method env met Private Virtual ty sign; - Location.prerr_warning loc - (Warnings.Undeclared_virtual_method met); - id, ty - end - in - Tmeth_val id, typ - | Texp_ident(_, _, {val_kind = Val_anc (sign, meths, cl_num)}) -> - obj_meths := Some meths; - let id = - match Meths.find met meths with - | id -> id - | exception Not_found -> - let valid_methods = - Meths.fold (fun lab _ acc -> lab :: acc) meths [] - in - raise (error(e.pexp_loc, env, - Undefined_self_method (met, valid_methods))) - in - let typ = Btype.method_type met sign in - let (self_path, _) = - Env.find_value_by_name - (Longident.Lident ("self-" ^ cl_num)) env - in - Tmeth_ancestor(id, self_path), typ - | _ -> - let ty = - match filter_method env met obj.exp_type with - | ty -> ty - | exception Filter_method_failed err -> - let err = - match err with - | Unification_error err -> - Expr_type_clash(err, explanation, None) - | Not_an_object ty -> - Not_an_object(ty, explanation) - | Not_a_method -> - let valid_methods = - match get_desc (expand_head env obj.exp_type) with - | Tobject (fields, _) -> - let (fields, _) = Ctype.flatten_fields fields in - let collect_fields li (meth, meth_kind, _meth_ty) = - if field_kind_repr meth_kind = Fpublic - then meth::li else li - in - Some (List.fold_left collect_fields [] fields) - | _ -> None - in - Undefined_method(obj.exp_type, met, valid_methods) - in - raise (error(e.pexp_loc, env, err)) - in - Tmeth_name met, ty + let obj = type_exp env e in + begin try + let (obj,meth,typ) = + with_local_level_if_principal + (fun () -> type_send env loc explanation e met) + ~post:(fun (_,_,typ) -> generalize_structure typ) in - if !Clflags.principal then begin - end_def (); - generalize_structure typ; - end; let typ = match get_desc typ with | Tpoly (ty, []) -> @@ -3743,7 +4020,7 @@ and type_expect_ if !Clflags.principal && get_level typ <> generic_level then Location.prerr_warning loc (Warnings.Not_principal "this use of a polymorphic method"); - snd (instance_poly false tl ty) + snd (instance_poly ~fixed:false tl ty) | Tvar _ -> let ty' = newvar () in unify env (instance typ) (newty(Tpoly(ty',[]))); @@ -3759,11 +4036,10 @@ and type_expect_ exp_type = typ; exp_attributes = sexp.pexp_attributes; exp_env = env } - with Error (_, _, Undefined_method _) -> + with Error (_, _, Undefined_method (_, _, valid_methods)) -> let valid_methods = - match !obj_meths with - | Some meths -> - Some (Meths.fold (fun meth _meth_ty li -> meth::li) meths []) + match valid_methods with + | Some meths -> Some meths | None -> match get_desc (expand_head env obj.exp_type) with | Tobject (fields, _) -> @@ -3861,48 +4137,61 @@ and type_expect_ assert false end | Pexp_letmodule(name, smodl, sbody) -> - let ty = newvar() in - (* remember original level *) - begin_def (); - let context = Typetexp.narrow () in - let modl, md_shape = !type_module env smodl in - Mtype.lower_nongen (get_level ty) modl.mod_type; - let pres = - match modl.mod_type with - | Mty_alias _ -> Mp_absent - | _ -> Mp_present - in - let scope = create_scope () in - let md = - { md_type = modl.mod_type; md_attributes = []; md_loc = name.loc; - md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); } - in - let (id, new_env) = - match name.txt with - | None -> None, env - | Some name -> - let id, env = - Env.enter_module_declaration ~scope ~shape:md_shape name pres md env + let lv = get_current_level () in + let (id, pres, modl, _, body) = + with_local_level begin fun () -> + let modl, pres, id, new_env = + Typetexp.TyVarEnv.with_local_scope begin fun () -> + let modl, md_shape = !type_module env smodl in + Mtype.lower_nongen lv modl.mod_type; + let pres = + match modl.mod_type with + | Mty_alias _ -> Mp_absent + | _ -> Mp_present + in + let scope = create_scope () in + let md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) in + let md_shape = Shape.set_uid_if_none md_shape md_uid in + let md = + { md_type = modl.mod_type; md_attributes = []; + md_loc = name.loc; + md_uid; } + in + let (id, new_env) = + match name.txt with + | None -> None, env + | Some name -> + let id, env = + Env.enter_module_declaration + ~scope ~shape:md_shape name pres md env + in + Some id, env + in + modl, pres, id, new_env + end in - Some id, env + (* Ideally, we should catch Expr_type_clash errors + in type_expect triggered by escaping identifiers + from the local module and refine them into + Scoping_let_module errors + *) + let body = type_expect new_env sbody ty_expected_explained in + (id, pres, modl, new_env, body) + end + ~post: begin fun (_id, _pres, _modl, new_env, body) -> + (* Ensure that local definitions do not leak. *) + (* required for implicit unpack *) + enforce_current_level new_env body.exp_type + end in - Typetexp.widen context; - (* ideally, we should catch Expr_type_clash errors - in type_expect triggered by escaping identifiers from the local module - and refine them into Scoping_let_module errors - *) - let body = type_expect new_env sbody ty_expected_explained in - (* go back to original level *) - end_def (); - Ctype.unify_var new_env ty body.exp_type; re { exp_desc = Texp_letmodule(id, name, pres, modl, body); exp_loc = loc; exp_extra = []; - exp_type = ty; + exp_type = body.exp_type; exp_attributes = sexp.pexp_attributes; exp_env = env } | Pexp_letexception(cd, sbody) -> - let (cd, newenv) = Typedecl.transl_exception env cd in + let (cd, newenv, _shape) = Typedecl.transl_exception env cd in let body = type_expect newenv sbody ty_expected_explained in re { exp_desc = Texp_letexception(cd, body); @@ -3921,8 +4210,14 @@ and type_expect_ | _ -> instance Predef.type_unit in + let rec innermost_location loc_stack = + match loc_stack with + | [] -> loc + | [l] -> l + | _ :: s -> innermost_location s + in rue { - exp_desc = Texp_assert cond; + exp_desc = Texp_assert (cond, innermost_location sexp.pexp_loc_stack); exp_loc = loc; exp_extra = []; exp_type; exp_attributes = sexp.pexp_attributes; @@ -3951,18 +4246,17 @@ and type_expect_ exp_env = env; } | Pexp_poly(sbody, sty) -> - if !Clflags.principal then begin_def (); let ty, cty = - match sty with None -> ty_expected, None - | Some sty -> - let sty = Ast_helper.Typ.force_poly sty in - let cty = Typetexp.transl_simple_type env false sty in - cty.ctyp_type, Some cty + with_local_level_if_principal + ~post:(fun (ty,_) -> generalize_structure ty) + begin fun () -> + match sty with None -> protect_expansion env ty_expected, None + | Some sty -> + let sty = Ast_helper.Typ.force_poly sty in + let cty = Typetexp.transl_simple_type env ~closed:false sty in + cty.ctyp_type, Some cty + end in - if !Clflags.principal then begin - end_def (); - generalize_structure ty - end; if sty <> None then with_explanation (fun () -> unify_exp_types loc env (instance ty) (instance ty_expected)); @@ -3973,16 +4267,20 @@ and type_expect_ { exp with exp_type = instance ty } | Tpoly (ty', tl) -> (* One more level to generalize locally *) - begin_def (); - if !Clflags.principal then begin_def (); - let vars, ty'' = instance_poly true tl ty' in - if !Clflags.principal then begin - end_def (); - generalize_structure ty'' - end; - let exp = type_expect env sbody (mk_expected ty'') in - end_def (); - generalize_and_check_univars env "method" exp ty_expected vars; + let (exp,_) = + with_local_level begin fun () -> + let vars, ty'' = + with_local_level_if_principal + (fun () -> instance_poly ~fixed:true tl ty') + ~post:(fun (_,ty'') -> generalize_structure ty'') + in + let exp = type_expect env sbody (mk_expected ty'') in + (exp, vars) + end + ~post: begin fun (exp,vars) -> + generalize_and_check_univars env "method" exp ty_expected vars + end + in { exp with exp_type = instance ty } | Tvar _ -> let exp = type_exp env sbody in @@ -3994,50 +4292,22 @@ and type_expect_ re { exp with exp_extra = (Texp_poly cty, loc, sexp.pexp_attributes) :: exp.exp_extra } | Pexp_newtype({txt=name} as label_loc, sbody) -> - let ty = - if Typetexp.valid_tyvar_name name then - newvar ~name () - else - newvar () + let body, ety, id, uid = type_newtype loc env name (fun env -> + let expr = type_exp env sbody in + expr, expr.exp_type) in - (* remember original level *) - begin_def (); - (* Create a fake abstract type declaration for name. *) - let decl = new_local_type ~loc () in - let scope = create_scope () in - let (id, new_env) = Env.enter_type ~scope name decl env in - - let body = type_exp new_env sbody in - (* Replace every instance of this type constructor in the resulting - type. *) - let seen = Hashtbl.create 8 in - let rec replace t = - if Hashtbl.mem seen (get_id t) then () - else begin - Hashtbl.add seen (get_id t) (); - match get_desc t with - | Tconstr (Path.Pident id', _, _) when id == id' -> link_type t ty - | _ -> Btype.iter_type_expr replace t - end - in - let ety = Subst.type_expr Subst.identity body.exp_type in - replace ety; - (* back to original level *) - end_def (); - (* lower the levels of the result type *) - (* unify_var env ty ety; *) - (* non-expansive if the body is non-expansive, so we don't introduce any new extra node in the typed AST. *) rue { body with exp_loc = loc; exp_type = ety; exp_extra = - (Texp_newtype' (id, label_loc), loc, sexp.pexp_attributes) :: body.exp_extra } + (Texp_newtype' (id, label_loc, uid), loc, sexp.pexp_attributes) :: body.exp_extra } | Pexp_pack m -> let (p, fl) = match get_desc (Ctype.expand_head env (instance ty_expected)) with Tpackage (p, fl) -> if !Clflags.principal && - get_level (Ctype.expand_head env ty_expected) + get_level (Ctype.expand_head env + (protect_expansion env ty_expected)) < Btype.generic_level then Location.prerr_warning loc @@ -4090,37 +4360,39 @@ and type_expect_ let ty_acc = newty (Ttuple [ty_acc; ty]) in loop spat_acc ty_acc rest in - if !Clflags.principal then begin_def (); - let let_loc = slet.pbop_op.loc in - let op_path, op_desc = type_binding_op_ident env slet.pbop_op in - let op_type = instance op_desc.val_type in - let spat_params, ty_params = loop slet.pbop_pat (newvar ()) sands in - let ty_func_result = newvar () in - let ty_func = - newty (Tarrow(Nolabel, ty_params, ty_func_result, commu_ok)) in - let ty_result = newvar () in - let ty_andops = newvar () in - let ty_op = - newty (Tarrow(Nolabel, ty_andops, - newty (Tarrow(Nolabel, ty_func, ty_result, commu_ok)), commu_ok)) + let op_path, op_desc, op_type, spat_params, ty_params, + ty_func_result, ty_result, ty_andops = + with_local_level_iter_if_principal + ~post:generalize_structure begin fun () -> + let let_loc = slet.pbop_op.loc in + let op_path, op_desc = type_binding_op_ident env slet.pbop_op in + let op_type = instance op_desc.val_type in + let spat_params, ty_params = loop slet.pbop_pat (newvar ()) sands in + let ty_func_result = newvar () in + let ty_func = + newty (Tarrow(Nolabel, ty_params, ty_func_result, commu_ok)) in + let ty_result = newvar () in + let ty_andops = newvar () in + let ty_op = + newty (Tarrow(Nolabel, ty_andops, + newty (Tarrow(Nolabel, ty_func, ty_result, commu_ok)), commu_ok)) + in + begin try + unify env op_type ty_op + with Unify err -> + raise(error(let_loc, env, Letop_type_clash(slet.pbop_op.txt, err))) + end; + ((op_path, op_desc, op_type, spat_params, ty_params, + ty_func_result, ty_result, ty_andops), + [ty_andops; ty_params; ty_func_result; ty_result]) + end in - begin try - unify env op_type ty_op - with Unify err -> - raise(error(let_loc, env, Letop_type_clash(slet.pbop_op.txt, err))) - end; - if !Clflags.principal then begin - end_def (); - generalize_structure ty_andops; - generalize_structure ty_params; - generalize_structure ty_func_result; - generalize_structure ty_result - end; let exp, ands = type_andops env slet.pbop_exp sands ty_andops in let scase = Ast_helper.Exp.case spat_params sbody in let cases, partial = type_cases Value env - ty_params (mk_expected ty_func_result) true loc [scase] + ty_params (mk_expected ty_func_result) + ~check_if_total:true loc [scase] in let body = match cases with @@ -4189,6 +4461,178 @@ and type_expect_ exp_attributes = sexp.pexp_attributes; exp_env = env } +and expression_constraint pexp = + { type_without_constraint = (fun env -> + let expr = type_exp env pexp in + expr, expr.exp_type); + type_with_constraint = + (fun env ty -> type_argument env pexp ty (instance ty)); + is_self = + (fun expr -> + match expr.exp_desc with + | Texp_ident (_, _, { val_kind = Val_self _ }) -> true + | _ -> false); + } + +(** Types a body in the scope of a coercion (with an optional constraint) + and returns the inferred type. See the comment on {!constraint_arg} for + an explanation of how this typechecking is polymorphic in the body. +*) +and type_coerce + : type a. a constraint_arg -> _ -> _ -> _ -> _ -> loc_arg:_ + -> a * type_expr * exp_extra = + fun constraint_arg env loc sty sty' ~loc_arg -> + (* Pretend separate = true, 1% slowdown for lablgtk *) + (* Also see PR#7199 for a problem with the following: + let separate = !Clflags.principal || Env.has_local_constraints env in*) + let { is_self; type_with_constraint; type_without_constraint } = + constraint_arg + in + match sty with + | None -> + let (cty', ty', force) = + Typetexp.transl_simple_type_delayed env sty' + in + let arg, arg_type, gen = + let lv = get_current_level () in + with_local_level begin fun () -> + let arg, arg_type = type_without_constraint env in + arg, arg_type, generalizable lv arg_type + end + ~post:(fun (_, arg_type, _) -> enforce_current_level env arg_type) + in + begin match !self_coercion, get_desc ty' with + | ((path, r) :: _, Tconstr (path', _, _)) + when is_self arg && Path.same path path' -> + (* prerr_endline "self coercion"; *) + r := loc :: !r; + force () + | _ when free_variables ~env arg_type = [] + && free_variables ~env ty' = [] -> + if not gen && (* first try a single coercion *) + let snap = snapshot () in + let ty, _b = enlarge_type env ty' in + try + force (); Ctype.unify env arg_type ty; true + with Unify _ -> + backtrack snap; false + then () + else begin try + let force' = subtype env arg_type ty' in + force (); force' (); + if not gen && !Clflags.principal then + Location.prerr_warning loc + (Warnings.Not_principal "this ground coercion"); + with Subtype err -> + (* prerr_endline "coercion failed"; *) + raise (Error (loc, env, Not_subtype err)) + end; + | _ -> + let ty, b = enlarge_type env ty' in + force (); + begin try Ctype.unify env arg_type ty with Unify err -> + let expanded = full_expand ~may_forget_scope:true env ty' in + raise(Error(loc_arg, env, + Coercion_failure ({ ty = ty'; expanded }, err, b))) + end + end; + (arg, ty', Texp_coerce (None, cty')) + | Some sty -> + let cty, ty, force, cty', ty', force' = + with_local_level_iter ~post:generalize_structure begin fun () -> + let (cty, ty, force) = + Typetexp.transl_simple_type_delayed env sty + and (cty', ty', force') = + Typetexp.transl_simple_type_delayed env sty' + in + ((cty, ty, force, cty', ty', force'), + [ ty; ty' ]) + end + in + begin try + let force'' = subtype env (instance ty) (instance ty') in + force (); force' (); force'' () + with Subtype err -> + raise (Error (loc, env, Not_subtype err)) + end; + (type_with_constraint env ty, + instance ty', Texp_coerce (Some cty, cty')) + +and type_constraint env sty = + (* Pretend separate = true, 1% slowdown for lablgtk *) + let cty = + with_local_level begin fun () -> + Typetexp.transl_simple_type env ~closed:false sty + end + ~post:(fun cty -> generalize_structure cty.ctyp_type) + in + cty.ctyp_type, Texp_constraint cty + +(** Types a body in the scope of a coercion (:>) or a constraint (:), and + unifies the inferred type with the expected type. + + @param loc the location of the overall constraint + @param loc_arg the location of the thing being constrained +*) +and type_constraint_expect + : type a. a constraint_arg -> _ -> _ -> loc_arg:_ -> _ -> _ -> a * _ * _ = + fun constraint_arg env loc ~loc_arg constraint_ ty_expected -> + let ret, ty, exp_extra = + match constraint_ with + | Pcoerce (ty_constrain, ty_coerce) -> + type_coerce constraint_arg env loc ty_constrain ty_coerce ~loc_arg + | Pconstraint ty_constrain -> + let ty, exp_extra = type_constraint env ty_constrain in + constraint_arg.type_with_constraint env ty, ty, exp_extra + in + unify_exp_types loc env ty (instance ty_expected); + ret, ty, exp_extra + +(** Typecheck the body of a newtype. The "body" of a newtype may be: + - an expression + - a suffix of function parameters together with a function body + That's why this function is polymorphic over the body. + + @param type_body A function that produces a type for the body given the + environment. When typechecking an expression, this is [type_exp]. + @return The type returned by [type_body] but with the Tconstr + nodes for the newtype properly linked. +*) +and type_newtype + : type a. _ -> _ -> _ -> (Env.t -> a * type_expr) -> a * type_expr * Ident.t * Uid.t = + fun loc env name type_body -> + let ty = + if Typetexp.valid_tyvar_name name then + newvar ~name () + else + newvar () + in + (* Use [with_local_level] just for scoping *) + with_local_level begin fun () -> + (* Create a fake abstract type declaration for [name]. *) + let decl = new_local_type ~loc Definition in + let scope = create_scope () in + let (id, new_env) = Env.enter_type ~scope name decl env in + + let result, exp_type = type_body new_env in + (* Replace every instance of this type constructor in the resulting + type. *) + let seen = Hashtbl.create 8 in + let rec replace t = + if Hashtbl.mem seen (get_id t) then () + else begin + Hashtbl.add seen (get_id t) (); + match get_desc t with + | Tconstr (Path.Pident id', _, _) when id == id' -> link_type t ty + | _ -> Btype.iter_type_expr replace t + end + in + let ety = Subst.type_expr Subst.identity exp_type in + replace ety; + let uid = decl.type_uid in + (result, ety, id, uid) + end + and type_ident env ?(recarg=Rejected) lid = let (path, desc) = Env.lookup_value ~loc:lid.loc lid.txt env in let is_recarg = @@ -4224,76 +4668,285 @@ and type_binding_op_ident env s = in path, desc -and type_function ?(in_function : (Location.t * type_expr) option) - loc attrs env ty_expected_explained arg_label caselist = - let { ty = ty_expected; explanation } = ty_expected_explained in - let (loc_fun, ty_fun) = - match in_function with Some p -> p - | None -> (loc, instance ty_expected) - in +(** Returns the argument type and then the return type. + + @param first Whether the parameter corresponding to the argument of + [ty_expected] is the first parameter to the (n-ary) function. This only + affects error messages. + @param in_function Information about the [Pexp_function] node that's in the + process of being typechecked (its overall type and its location). Again, + this is only used to improve error messages. +*) +and split_function_ty env ty_expected ~arg_label ~first ~in_function = + let { ty = ty_fun; explanation }, loc = in_function in let separate = !Clflags.principal || Env.has_local_constraints env in - if separate then begin_def (); - let (ty_arg, ty_res) = - try filter_arrow env (instance ty_expected) arg_label - with Filter_arrow_failed err -> - let err = match err with + with_local_level_iter_if separate ~post:generalize_structure begin fun () -> + let ty_arg, ty_res = + try filter_arrow env (instance ty_expected) arg_label + with Filter_arrow_failed err -> + let err = match err with | Unification_error unif_err -> - Expr_type_clash(unif_err, explanation, None) - | Label_mismatch { got; expected; expected_type} -> + Expr_type_clash (unif_err, explanation, None) + | Label_mismatch { got; expected; expected_type } -> Abstract_wrong_label { got; expected; expected_type; explanation } - | Not_a_function -> begin - match in_function with - | Some _ -> Too_many_arguments(ty_fun, explanation) - | None -> Not_a_function(ty_fun, explanation) + | Not_a_function -> + if first + then Not_a_function (ty_fun, explanation) + else Too_many_arguments (ty_fun, explanation) + in + (* Merlin: we recover with an expected type of 'a -> 'b *) + let level = get_level (instance ty_expected) in + raise_error (error(loc, env, err)); + (newvar2 level, ty_expected) + in + let ty_arg = + if is_optional arg_label then + let tv = newvar () in + begin + try unify env ty_arg (type_option tv) + with Unify _ -> assert false + end; + type_option tv + else ty_arg + in + (ty_arg, ty_res), [ ty_arg; ty_res ] + end + +(* Typecheck parameters one at a time followed by the body. Later parameters + are checked in the scope of earlier ones. That's necessary to support + constructs like [fun (type a) (x : a) -> ...] and + [fun (module M : S) (x : M.t) -> ...]. + + Operates like [type_expect] in that it unifies the "type of the remaining + function params + body" with [ty_expected], and returns out the inferred + type. + + See [split_function_ty] for the meaning of [first] and [in_function]. + + Returns (inferred_ty, params, body, newtypes, contains_gadt), where: + - [newtypes] are the newtypes immediately bound by the prefix of function + parameters. These should be added to an [exp_extra] node. + - [contains_gadt] is whether any of [params] contains a GADT. Note + this does not indicate whether [body] contains a GADT (if it's + [Tfunction_cases]). +*) +and type_function + env params_suffix body_constraint body ty_expected ~first ~in_function + = + let ty_fun, (loc_function : Location.t) = in_function in + (* The "rest of the function" extends from the start of the first parameter + to the end of the overall function. The parser does not construct such + a location so we forge one for type errors. + *) + let loc : Location.t = + match params_suffix, body with + | param :: _, _ -> + { loc_start = param.pparam_loc.loc_start; + loc_end = loc_function.loc_end; + loc_ghost = true; + } + | [], Pfunction_body pexp -> pexp.pexp_loc + | [], Pfunction_cases (_, loc_cases, _) -> loc_cases + in + match params_suffix with + | { pparam_desc = Pparam_newtype newtype; pparam_loc = _ } :: rest -> + (* Check everything else in the scope of (type a). *) + let (params, body, newtypes, contains_gadt), exp_type, nt_id, nt_uid = + type_newtype loc env newtype.txt (fun env -> + let exp_type, params, body, newtypes, contains_gadt = + (* mimic the typing of Pexp_newtype by minting a new type var, + like [type_exp]. + *) + type_function env rest body_constraint body (newvar ()) + ~first:false ~in_function + in + (params, body, newtypes, contains_gadt), exp_type) + in + (try with_explanation ty_fun.explanation (fun () -> + unify_exp_types loc env exp_type (instance ty_expected)); + with _ -> Msupport.erroneous_type_register ty_expected); + let newtype = nt_id, newtype, nt_uid in + exp_type, params, body, newtype :: newtypes, contains_gadt + | { pparam_desc = Pparam_val (arg_label, default_arg, pat); pparam_loc } + :: rest + -> + let ty_arg, ty_res = + split_function_ty env ty_expected ~arg_label ~first ~in_function + in + (* [ty_arg_internal] is the type of the parameter viewed internally + to the function. This is different than [ty_arg] exactly for + optional arguments with defaults, where the external [ty_arg] + is optional and the internal view is not optional. + *) + let ty_arg_internal, default_arg = + match default_arg with + | None -> ty_arg, None + | Some default -> + assert (is_optional arg_label); + let ty_default = newvar () in + begin + try unify env (type_option ty_default) ty_arg + with Unify _ -> assert false; + end; + (* Issue#12668: Retain type-directed disambiguation of + ?x:(y : Variant.t = Constr) + *) + let default = + match pat.ppat_desc with + | Ppat_constraint (_, sty) -> + let gloc = { default.pexp_loc with loc_ghost = true } in + Ast_helper.Exp.constraint_ default sty ~loc:gloc + | _ -> default + in + let default = type_expect env default (mk_expected ty_default) in + ty_default, Some default + in + let (pat, params, body, newtypes, contains_gadt), partial = + (* Check everything else in the scope of the parameter. *) + map_half_typed_cases Value env ty_arg_internal ty_res pat.ppat_loc + ~check_if_total:true + (* We don't make use of [case_data] here so we pass unit. *) + [ { pattern = pat; has_guard = false; needs_refute = false }, () ] + ~type_body:begin + fun () pat ~ext_env ~ty_expected ~ty_infer:_ + ~contains_gadt:param_contains_gadt -> + let _, params, body, newtypes, suffix_contains_gadt = + type_function ext_env rest body_constraint body + ty_expected ~first:false ~in_function + in + let contains_gadt = + if param_contains_gadt then + Contains_gadt + else + suffix_contains_gadt + in + (pat, params, body, newtypes, contains_gadt) end + |> function + (* The result must be a singleton because we passed a singleton + list above. *) + | [ result ], partial -> result, partial + | ([] | _ :: _ :: _), _ -> assert false in - (* Merlin: we recover with an expected type of 'a -> 'b *) - let level = get_level (instance ty_expected) in - raise_error (error(loc_fun, env, err)); - (newvar2 level, newvar2 level) - in - let ty_arg = - if is_optional arg_label then - let tv = newvar() in - begin - try unify env ty_arg (type_option tv) - with Unify _ -> assert false - end; - type_option tv - else ty_arg - in - if separate then begin - end_def (); - generalize_structure ty_arg; - generalize_structure ty_res - end; - let cases, partial = - type_cases Value ~in_function:(loc_fun,ty_fun) env - ty_arg (mk_expected ty_res) true loc caselist in - let not_nolabel_function ty = - let ls, tvar = list_labels env ty in - List.for_all ((<>) Nolabel) ls && not tvar - in - if is_optional arg_label && not_nolabel_function ty_res then - Location.prerr_warning (List.hd cases).c_lhs.pat_loc - Warnings.Unerasable_optional_argument; - let param = name_cases "param" cases in - re { - exp_desc = Texp_function { arg_label; param; cases; partial; }; - exp_loc = loc; exp_extra = []; - exp_type = - instance (newgenty (Tarrow(arg_label, ty_arg, ty_res, commu_ok))); - exp_attributes = attrs; - exp_env = env } + let exp_type = + instance (newgenty (Tarrow (arg_label, ty_arg, ty_res, commu_ok))) + in + (* This is quadratic, as it operates over the entire tail of the + type for each new parameter. Now that functions are n-ary, we + could possibly run this once. + *) + (try with_explanation ty_fun.explanation (fun () -> + unify_exp_types loc env exp_type (instance ty_expected)); + with _ -> Msupport.erroneous_type_register ty_expected); + (* This is quadratic, as it extracts all of the parameters from an arrow + type for each parameter that's added. Now that functions are n-ary, + there might be an opportunity to improve this. + *) + let not_nolabel_function ty = + let ls, tvar = list_labels env ty in + List.for_all (( <> ) Nolabel) ls && not tvar + in + if is_optional arg_label && not_nolabel_function ty_res + then + Location.prerr_warning + pat.pat_loc + Warnings.Unerasable_optional_argument; + let fp_kind, fp_param = + match default_arg with + | None -> + let param = name_pattern "param" [ pat ] in + Tparam_pat pat, param + | Some default_arg -> + let param = Ident.create_local "*opt*" in + Tparam_optional_default (pat, default_arg), param + in + let param = + { fp_kind; + fp_arg_label = arg_label; + fp_param; + fp_partial = partial; + fp_newtypes = List.map (fun (_,v,_) -> v) newtypes; + fp_loc = pparam_loc; + } + in + exp_type, param :: params, body, [], contains_gadt + | [] -> + let exp_type, body = + match body with + | Pfunction_body body -> + let body = + match body_constraint with + | None -> type_expect env body (mk_expected ty_expected) + | Some constraint_ -> + let body_loc = body.pexp_loc in + let body, exp_type, exp_extra = + type_constraint_expect (expression_constraint body) + env body_loc ~loc_arg:body_loc constraint_ ty_expected + in + { body with + exp_extra = (exp_extra, body_loc, []) :: body.exp_extra; + exp_type; + } + in + body.exp_type, Tfunction_body body + | Pfunction_cases (cases, _, attributes) -> + let type_cases_expect env ty_expected = + type_function_cases_expect + env ty_expected loc cases attributes ~first ~in_function + in + let (cases, partial, exp_type), exp_extra = + match body_constraint with + | None -> type_cases_expect env ty_expected, None + | Some constraint_ -> + (* The typing of function case coercions/constraints is + analogous to the typing of expression coercions/constraints. + + - [type_with_constraint]: If there is a constraint, then call + [type_argument] on the cases, and discard the cases' + inferred type in favor of the constrained type. (Function + cases aren't inferred, so [type_argument] would just call + [type_expect] straightaway, so we do the same here.) + - [type_without_constraint]: If there is just a coercion and + no constraint, call [type_exp] on the cases and surface the + cases' inferred type to [type_constraint_expect]. *) + let function_cases_constraint_arg = + { is_self = (fun _ -> false); + type_with_constraint = (fun env ty -> + let cases, partial, _ = type_cases_expect env ty in + cases, partial); + type_without_constraint = (fun env -> + let cases, partial, ty_fun = + (* The analogy to [type_exp] for expressions. *) + type_cases_expect env (newvar ()) + in + (cases, partial), ty_fun); + } + in + let (cases, partial), exp_type, exp_extra = + type_constraint_expect function_cases_constraint_arg + env loc constraint_ ty_expected ~loc_arg:loc + in + (cases, partial, exp_type), Some exp_extra + in + let param = name_cases "param" cases in + let body = + Tfunction_cases + { cases; partial; param; loc; exp_extra; attributes } + in + exp_type, body + in + (* [No_gadt] is fine because this return value is only meant to indicate + whether [params] (here, the empty list) contains any GADT, not whether + the body is a [Tfunction_cases] whose patterns include a GADT. + *) + exp_type, [], body, [], No_gadt and type_label_access env srecord usage lid = - if !Clflags.principal then begin_def (); - let record = type_exp ~recarg:Allowed env srecord in - if !Clflags.principal then begin - end_def (); - generalize_structure record.exp_type - end; + let record = + with_local_level_if_principal ~post:generalize_structure_exp + (fun () -> type_exp ~recarg:Allowed env srecord) + in let ty_exp = record.exp_type in let expected_type = match extract_concrete_record env ty_exp with @@ -4576,60 +5229,78 @@ and type_format loc str env = and type_label_exp create env loc ty_expected (lid, label, sarg) = (* Here also ty_expected may be at generic_level *) - begin_def (); let separate = !Clflags.principal || Env.has_local_constraints env in - if separate then (begin_def (); begin_def ()); - let (vars, ty_arg, ty_res) = instance_label true label in - if separate then begin - end_def (); - (* Generalize label information *) - generalize_structure ty_arg; - generalize_structure ty_res - end; - begin try - unify env (instance ty_res) (instance ty_expected) - with Unify err -> - raise (error(lid.loc, env, Label_mismatch(lid.txt, err))) - end; - (* Instantiate so that we can generalize internal nodes *) - let ty_arg = instance ty_arg in - if separate then begin - end_def (); - (* Generalize information merged from ty_expected *) - generalize_structure ty_arg - end; - if label.lbl_private = Private then - if create then - raise (error(loc, env, Private_type ty_expected)) - else - raise (error(lid.loc, env, Private_label(lid.txt, ty_expected))); + (* #4682: we try two type-checking approaches for [arg] using backtracking: + - first try: we try with [ty_arg] as expected type; + - second try; if that fails, we backtrack and try without + *) + let (vars, ty_arg, snap, arg) = + (* try the first approach *) + with_local_level begin fun () -> + let (vars, ty_arg) = + with_local_level_iter_if separate begin fun () -> + let (vars, ty_arg, ty_res) = + with_local_level_iter_if separate ~post:generalize_structure + begin fun () -> + let ((_, ty_arg, ty_res) as r) = + instance_label ~fixed:true label in + (r, [ty_arg; ty_res]) + end + in + begin try + unify env (instance ty_res) (instance ty_expected) + with Unify err -> + raise (error(lid.loc, env, Label_mismatch(lid.txt, err))) + end; + (* Instantiate so that we can generalize internal nodes *) + let ty_arg = instance ty_arg in + ((vars, ty_arg), [ty_arg]) + end + ~post:generalize_structure + in + + if label.lbl_private = Private then + if create then + raise (error(loc, env, Private_type ty_expected)) + else + raise (error(lid.loc, env, Private_label(lid.txt, ty_expected))); + let snap = if vars = [] then None else Some (Btype.snapshot ()) in + let arg = type_argument env sarg ty_arg (instance ty_arg) in + (vars, ty_arg, snap, arg) + end + (* Note: there is no generalization logic here as could be expected, + because it is part of the backtracking logic below. *) + in let arg = - let snap = if vars = [] then None else Some (Btype.snapshot ()) in - let arg = type_argument env sarg ty_arg (instance ty_arg) in - end_def (); try if (vars = []) then arg else begin + (* We detect if the first try failed here, + during generalization. *) if maybe_expansive arg then lower_contravariant env arg.exp_type; generalize_and_check_univars env "field value" arg label.lbl_arg vars; {arg with exp_type = instance arg.exp_type} end - with exn when maybe_expansive arg -> try - (* Try to retype without propagating ty_arg, cf PR#4862 *) + with first_try_exn when maybe_expansive arg -> try + (* backtrack and try the second approach *) Option.iter Btype.backtrack snap; - begin_def (); - let arg = type_exp env sarg in - end_def (); - lower_contravariant env arg.exp_type; - begin_def (); - let arg = {arg with exp_type = instance arg.exp_type} in - unify_exp env arg (instance ty_arg); - end_def (); - generalize_and_check_univars env "field value" arg label.lbl_arg vars; + let arg = with_local_level (fun () -> type_exp env sarg) + ~post:(fun arg -> lower_contravariant env arg.exp_type) + in + let arg = + with_local_level begin fun () -> + let arg = {arg with exp_type = instance arg.exp_type} in + unify_exp env arg (instance ty_arg); + arg + end + ~post: begin fun arg -> + generalize_and_check_univars env "field value" arg label.lbl_arg vars + end + in {arg with exp_type = instance arg.exp_type} with Error (_, _, Less_general _) as e -> raise e - | _ -> raise exn (* In case of failure return the first error *) + | _ -> raise first_try_exn in (lid, label, arg) @@ -4658,12 +5329,10 @@ and type_argument ?explanation ?recarg env sarg ty_expected' ty_expected = Some (safe_expect, lv) -> (* apply optional arguments when expected type is "" *) (* we must be very careful about not breaking the semantics *) - if !Clflags.principal then begin_def (); - let texp = type_exp env sarg in - if !Clflags.principal then begin - end_def (); - generalize_structure texp.exp_type - end; + let texp = + with_local_level_if_principal ~post:generalize_structure_exp + (fun () -> type_exp env sarg) + in let rec make_args args ty_fun = match get_desc (expand_head env ty_fun) with | Tarrow (l,ty_arg,ty_fun,_) when is_optional l -> @@ -4684,7 +5353,7 @@ and type_argument ?explanation ?recarg env sarg ty_expected' ty_expected = (lv <> generic_level || get_level ty_fun' <> generic_level) and ty_fun = instance ty_fun' in let ty_arg, ty_res = - match get_desc (expand_head env ty_expected') with + match get_desc (expand_head env ty_expected) with Tarrow(Nolabel,ty_arg,ty_res,_) -> ty_arg, ty_res | _ -> assert false in @@ -4701,7 +5370,10 @@ and type_argument ?explanation ?recarg env sarg ty_expected' ty_expected = } in let exp_env = Env.add_value id desc env in - {pat_desc = Tpat_var (id, mknoloc name); pat_type = ty;pat_extra=[]; + {pat_desc = + Tpat_var (id, mknoloc name, desc.val_uid); + pat_type = ty; + pat_extra=[]; pat_attributes = []; pat_loc = Location.none; pat_env = env}, {exp_type = ty; exp_loc = Location.none; exp_env = exp_env; @@ -4717,11 +5389,16 @@ and type_argument ?explanation ?recarg env sarg ty_expected' ty_expected = (texp, args @ [Nolabel, Some eta_var])} in - let cases = [case eta_pat e] in + let cases = [ case eta_pat e ] in + let cases_loc = { texp.exp_loc with loc_ghost = true } in let param = name_cases "param" cases in { texp with exp_type = ty_fun; exp_desc = - Texp_function { arg_label = Nolabel; param; cases; - partial = Total; } } + Texp_function ([], + Tfunction_cases + { cases; partial = Total; param; loc = cases_loc; + exp_extra = None; attributes = []; + }) + } in Location.prerr_warning texp.exp_loc (Warnings.Eliminated_optional_arguments @@ -4733,7 +5410,7 @@ and type_argument ?explanation ?recarg env sarg ty_expected' ty_expected = re { texp with exp_type = ty_fun; exp_desc = Texp_let (Nonrecursive, [{vb_pat=let_pat; vb_expr=texp; vb_attributes=[]; - vb_loc=Location.none; + vb_loc=Location.none; vb_rec_kind = Dynamic; }], func let_var) } end @@ -4790,9 +5467,22 @@ and type_application env funct sargs = Msupport.resume_raise (error(funct.exp_loc, env, Incoherent_label_order)) | _ -> + let previous_arg_loc = + (* [typed_args] is the arguments typed until now, in reverse + order of appearance. Not all arguments have a location + attached (eg. an optional argument that is not passed). *) + typed_args + |> List.find_map + (function (_, Some (_, loc)) -> loc | _ -> None) + |> Option.value ~default:funct.exp_loc + in Msupport.resume_raise - (error(funct.exp_loc, env, Apply_non_function - (expand_head env funct.exp_type))) + (error(funct.exp_loc, env, Apply_non_function { + funct; + func_ty = expand_head env funct.exp_type; + res_ty = expand_head env ty_res; + previous_arg_loc; + extra_arg_loc = sarg.pexp_loc; })) with Msupport.Resume -> newvar(), ty_fun in @@ -4802,7 +5492,7 @@ and type_application env funct sargs = unify_exp env arg (type_option(newvar())); arg in - (ty_res, (lbl, Some arg) :: typed_args) + (ty_res, (lbl, Some (arg, Some sarg.pexp_loc)) :: typed_args) in let ignore_labels = !Clflags.classic || @@ -4822,11 +5512,32 @@ and type_application env funct sargs = end in let warned = ref false in + (* [args] remember the location of each argument in sources. *) let rec type_args args ty_fun ty_fun0 sargs = + let type_unknown_args () = + (* We're not looking at a *known* function type anymore, or there are no + arguments left. *) + let ty_fun, typed_args = + List.fold_left type_unknown_arg (ty_fun0, args) sargs + in + let args = + (* Force typing of arguments. + Careful: the order matters here. Using [List.rev_map] would be + incorrect. *) + List.map + (function + | l, None -> l, None + | l, Some (f, _loc) -> l, Some (f ())) + (List.rev typed_args) + in + let result_ty = instance (result_type !omitted_parameters ty_fun) in + args, result_ty + in + if sargs = [] then type_unknown_args () else let ty_fun' = expand_head env ty_fun in match get_desc ty_fun', get_desc (expand_head env ty_fun0) with | Tarrow (l, ty, ty_fun, com), Tarrow (_, ty0, ty_fun0, _) - when sargs <> [] && is_commu_ok com -> + when is_commu_ok com -> let lv = get_level ty_fun' in let may_warn loc w = if not !warned && !Clflags.principal && lv <> generic_level @@ -4838,24 +5549,22 @@ and type_application env funct sargs = let name = label_name l and optional = is_optional l in let use_arg sarg l' = - Some ( - if not optional || is_optional l' then - (fun () -> type_argument env sarg ty ty0) - else begin - may_warn sarg.pexp_loc - (Warnings.Not_principal "using an optional argument here"); - (fun () -> option_some env (type_argument env sarg - (extract_option_type env ty) - (extract_option_type env ty0))) - end - ) + if not optional || is_optional l' then + (fun () -> type_argument env sarg ty ty0) + else begin + may_warn sarg.pexp_loc + (Warnings.Not_principal "using an optional argument here"); + (fun () -> option_some env (type_argument env sarg + (extract_option_type env ty) + (extract_option_type env ty0))) + end in let eliminate_optional_arg () = may_warn funct.exp_loc (Warnings.Non_principal_labels "eliminated optional argument"); eliminated_optional_arguments := (l,ty,lv) :: !eliminated_optional_arguments; - Some (fun () -> option_none env (instance ty) Location.none) + (fun () -> option_none env (instance ty) Location.none) in let remaining_sargs, arg = if ignore_labels then begin @@ -4864,7 +5573,7 @@ and type_application env funct sargs = | [] -> assert false | (l', sarg) :: remaining_sargs -> if name = label_name l' || (not optional && l' = Nolabel) then - (remaining_sargs, use_arg sarg l') + (remaining_sargs, Some (use_arg sarg l', Some sarg.pexp_loc)) else if optional && not (List.exists (fun (l, _) -> name = label_name l) @@ -4872,7 +5581,7 @@ and type_application env funct sargs = List.exists (function (Nolabel, _) -> true | _ -> false) sargs then - (sargs, eliminate_optional_arg ()) + (sargs, Some (eliminate_optional_arg (), Some sarg.pexp_loc)) else raise(error(sarg.pexp_loc, env, Apply_wrong_label(l', ty_fun', optional))) @@ -4888,11 +5597,11 @@ and type_application env funct sargs = if not optional && is_optional l' then Location.prerr_warning sarg.pexp_loc (Warnings.Nonoptional_label (Printtyp.string_of_label l)); - remaining_sargs, use_arg sarg l' + remaining_sargs, Some (use_arg sarg l', Some sarg.pexp_loc) | None -> sargs, if optional && List.mem_assoc Nolabel sargs then - eliminate_optional_arg () + Some (eliminate_optional_arg (), None) else begin (* No argument was given for this parameter, we abstract over it. *) @@ -4904,39 +5613,27 @@ and type_application env funct sargs = in type_args ((l,arg)::args) ty_fun ty_fun0 remaining_sargs | _ -> - (* We're not looking at a *known* function type anymore, or there are no - arguments left. *) - let ty_fun, typed_args = - List.fold_left type_unknown_arg (ty_fun0, args) sargs - in - let args = - (* Force typing of arguments. - Careful: the order matters here. Using [List.rev_map] would be - incorrect. *) - List.map - (function - | l, None -> l, None - | l, Some f -> l, Some (f ())) - (List.rev typed_args) - in - let result_ty = instance (result_type !omitted_parameters ty_fun) in - args, result_ty + type_unknown_args () in let is_ignore funct = is_prim ~name:"%ignore" funct && (try ignore (filter_arrow env (instance funct.exp_type) Nolabel); true with Filter_arrow_failed _ -> false) in - match sargs with - | (* Special case for ignore: avoid discarding warning *) - [Nolabel, sarg] when is_ignore funct -> - let ty_arg, ty_res = filter_arrow env (instance funct.exp_type) Nolabel in - let exp = type_expect env sarg (mk_expected ty_arg) in - check_partial_application ~statement:false exp; - ([Nolabel, Some exp], ty_res) - | _ -> - let ty = funct.exp_type in - type_args [] ty (instance ty) sargs + (* Extra scope to check for non-returning functions *) + with_local_level begin fun () -> + match sargs with + | (* Special case for ignore: avoid discarding warning *) + [Nolabel, sarg] when is_ignore funct -> + let ty_arg, ty_res = + filter_arrow env (instance funct.exp_type) Nolabel in + let exp = type_expect env sarg (mk_expected ty_arg) in + check_partial_application ~statement:false exp; + ([Nolabel, Some exp], ty_res) + | _ -> + let ty = funct.exp_type in + type_args [] ty (instance ty) sargs + end and type_construct env loc lid sarg ty_expected_explained attrs = let { ty = ty_expected; explanation } = ty_expected_explained in @@ -4970,25 +5667,32 @@ and type_construct env loc lid sarg ty_expected_explained attrs = raise(error(loc, env, Constructor_arity_mismatch (lid.txt, constr.cstr_arity, List.length sargs))); let separate = !Clflags.principal || Env.has_local_constraints env in - if separate then (begin_def (); begin_def ()); - let (ty_args, ty_res, _) = instance_constructor constr in - let texp = - re { - exp_desc = Texp_construct(lid, constr, []); - exp_loc = loc; exp_extra = []; - exp_type = ty_res; - exp_attributes = attrs; - exp_env = env } in - if separate then begin - end_def (); - generalize_structure ty_res; - with_explanation explanation (fun () -> - unify_exp env {texp with exp_type = instance ty_res} - (instance ty_expected)); - end_def (); - List.iter generalize_structure ty_args; - generalize_structure ty_res; - end; + let ty_args, ty_res, texp = + with_local_level_iter_if separate ~post:generalize_structure begin fun () -> + let ty_args, ty_res, texp = + with_local_level_if separate begin fun () -> + let (ty_args, ty_res, _) = + instance_constructor Keep_existentials_flexible constr + in + let texp = + re { + exp_desc = Texp_construct(lid, constr, []); + exp_loc = loc; exp_extra = []; + exp_type = ty_res; + exp_attributes = attrs; + exp_env = env } in + (ty_args, ty_res, texp) + end + ~post: begin fun (_, ty_res, texp) -> + generalize_structure ty_res; + with_explanation explanation (fun () -> + unify_exp env {texp with exp_type = instance ty_res} + (instance ty_expected)); + end + in + ((ty_args, ty_res, texp), ty_res::ty_args) + end + in let ty_args0, ty_res = match instance_list (ty_res :: ty_args) with t :: tl -> tl, t @@ -5029,13 +5733,29 @@ and type_construct env loc lid sarg ty_expected_explained attrs = and type_statement ?explanation env sexp = let has_errors = Msupport.monitor_errors () in - begin_def(); - let exp = type_exp env sexp in - end_def(); - let ty = expand_head env exp.exp_type and tv = newvar() in - if is_Tvar ty && get_level ty > get_level tv && not !has_errors then + (* OCaml 5.2.0 changed the type of 'while' to give 'while true do e done' + a polymorphic type. The change has the potential to trigger a + nonreturning-statement warning in existing code that follows + 'while true' with some other statement, e.g. + + while true do e done; assert false + + To avoid this issue, we disable the warning in this particular case. + We might consider re-enabling it at a point when most users have + migrated to OCaml 5.2.0 or later. *) + let allow_polymorphic e = match e.exp_desc with + | Texp_while _ -> true + | _ -> false + in + (* Raise the current level to detect non-returning functions *) + let exp = with_local_level (fun () -> type_exp env sexp) in + let subexp = final_subexpression exp in + let ty = expand_head env exp.exp_type in + if is_Tvar ty && not !has_errors + && get_level ty > get_current_level () + && not (allow_polymorphic subexp) then Location.prerr_warning - (final_subexpression exp).exp_loc + subexp.exp_loc Warnings.Nonreturning_statement; if !Clflags.strict_sequence then let expected_ty = instance Predef.type_unit in @@ -5044,82 +5764,47 @@ and type_statement ?explanation env sexp = exp else begin if not !has_errors then check_partial_application ~statement:true exp; - unify_var env tv ty; + enforce_current_level env ty; exp end -and type_unpacks ?(in_function : (Location.t * type_expr) option) - env (unpacks : to_unpack list) sbody expected_ty = - if unpacks = [] then type_expect ?in_function env sbody expected_ty else - let ty = newvar() in - (* remember original level *) - let extended_env, tunpacks = - List.fold_left (fun (env, tunpacks) unpack -> - begin_def (); - let context = Typetexp.narrow () in - let modl, md_shape = - !type_module env - Ast_helper.( - Mod.unpack ~loc:unpack.tu_loc - (Exp.ident ~loc:unpack.tu_name.loc - (mkloc (Longident.Lident unpack.tu_name.txt) - unpack.tu_name.loc))) - in - Mtype.lower_nongen (get_level ty) modl.mod_type; - let pres = - match modl.mod_type with - | Mty_alias _ -> Mp_absent - | _ -> Mp_present - in - let scope = create_scope () in - let md = - { md_type = modl.mod_type; md_attributes = []; - md_loc = unpack.tu_name.loc; - md_uid = unpack.tu_uid; } - in - let (id, env) = - Env.enter_module_declaration ~scope ~shape:md_shape - unpack.tu_name.txt pres md env - in - Typetexp.widen context; - env, (id, unpack.tu_name, pres, modl) :: tunpacks - ) (env, []) unpacks - in - (* ideally, we should catch Expr_type_clash errors - in type_expect triggered by escaping identifiers from the local module - and refine them into Scoping_let_module errors - *) - let body = type_expect ?in_function extended_env sbody expected_ty in - let exp_loc = { body.exp_loc with loc_ghost = true } in - let exp_attributes = [Ast_helper.Attr.mk (mknoloc "#modulepat") (PStr [])] in - List.fold_left (fun body (id, name, pres, modl) -> - (* go back to parent level *) - end_def (); - Ctype.unify_var extended_env ty body.exp_type; - re { - exp_desc = Texp_letmodule(Some id, { name with txt = Some name.txt }, - pres, modl, body); - exp_loc; - exp_attributes; - exp_extra = []; - exp_type = ty; - exp_env = env } - ) body tunpacks +(* Most of the arguments are the same as [type_cases]. -(* Typing of match cases *) -and type_cases - : type k . k pattern_category -> - ?in_function:_ -> _ -> _ -> _ -> _ -> _ -> Parsetree.case list -> - k case list * partial - = fun category ?in_function env - ty_arg ty_res_explained partial_flag loc caselist -> + Takes a callback which is responsible for typing the body of the case. + The arguments are documented inline in the type signature. + + It takes a callback rather than returning the half-typed cases directly + because the typing of the body must take place at an increased level. + + The overall function returns: + - The data returned by the callback + - Whether the cases' patterns are partial or total +*) +and map_half_typed_cases + : type k ret case_data. + ?additional_checks_for_split_cases:((_ * ret) list -> unit) + -> k pattern_category -> _ -> _ -> _ -> _ + -> (untyped_case * case_data) list + -> type_body:( + case_data + -> k general_pattern (* the typed pattern *) + -> ext_env:_ (* environment with module variables / pattern variables *) + -> ty_expected:_ (* type to check body in scope of *) + -> ty_infer:_ (* type to infer for body *) + -> contains_gadt:_ (* whether the pattern contains a GADT *) + -> ret) + -> check_if_total:bool (* if false, assume Partial right away *) + -> ret list * partial + = fun ?additional_checks_for_split_cases + category env ty_arg ty_res loc caselist ~type_body ~check_if_total -> let has_errors = Msupport.monitor_errors () in (* ty_arg is _fully_ generalized *) - let { ty = ty_res; explanation } = ty_res_explained in - let patterns = List.map (fun {pc_lhs=p} -> p) caselist in + let patterns = List.map (fun ((x : untyped_case), _) -> x.pattern) caselist in let contains_polyvars = List.exists contains_polymorphic_variant patterns in let erase_either = contains_polyvars && contains_variant_either ty_arg in let may_contain_gadts = List.exists may_contain_gadts patterns in + let may_contain_modules = List.exists may_contain_modules patterns in + let create_inner_level = may_contain_gadts || may_contain_modules in let ty_arg = if (may_contain_gadts || erase_either) && not !Clflags.principal then correct_levels ty_arg else ty_arg @@ -5131,147 +5816,142 @@ and type_cases | _ -> false in let needs_exhaust_check = match caselist with - [{pc_rhs = {pexp_desc = Pexp_unreachable}}] -> true - | [{pc_lhs}] when is_var pc_lhs -> false + [ ({ needs_refute = true }, _) ] -> true + | [ ({ pattern }, _) ] when is_var pattern -> false | _ -> true in let outer_level = get_current_level () in - let lev = - if may_contain_gadts then begin_def (); - get_current_level () + with_local_level_iter_if create_inner_level begin fun () -> + let lev = get_current_level () in + let allow_modules = + if may_contain_modules + then + (* The corresponding check for scope escape is done together with + the check for GADT-induced existentials by + [with_local_level_iter_if create_inner_level]. + *) + Modules_allowed { scope = lev } + else Modules_rejected in let take_partial_instance = if erase_either then Some false else None in - begin_def (); (* propagation of the argument *) - let pattern_force = ref [] in -(* Format.printf "@[%i %i@ %a@]@." lev (get_current_level()) - Printtyp.raw_type_expr ty_arg; *) - let half_typed_cases = - List.map - (fun ({pc_lhs; pc_guard = _; pc_rhs = _} as case) -> - if !Clflags.principal then begin_def (); (* propagation of pattern *) - begin_def (); - let ty_arg = instance ?partial:take_partial_instance ty_arg in - end_def (); - generalize_structure ty_arg; - let (pat, ext_env, force, pvs, unpacks) = - type_pattern category ~lev env pc_lhs ty_arg - in - pattern_force := force @ !pattern_force; - let pat = - if !Clflags.principal then begin - end_def (); - iter_pattern_variables_type generalize_structure pvs; - { pat with pat_type = instance pat.pat_type } - end else pat - in - (* Ensure that no ambivalent pattern type escapes its branch *) - check_scope_escape pat.pat_loc env outer_level ty_arg; - { typed_pat = pat; - pat_type_for_unif = ty_arg; - untyped_case = case; - branch_env = ext_env; - pat_vars = pvs; - unpacks; - contains_gadt = contains_gadt (as_comp_pattern category pat); } + let half_typed_cases, ty_res, do_copy_types, ty_arg' = + (* propagation of the argument *) + with_local_level begin fun () -> + let pattern_force = ref [] in + (* Format.printf "@[%i %i@ %a@]@." lev (get_current_level()) + Printtyp.raw_type_expr ty_arg; *) + let half_typed_cases = + List.map + (fun ({ Parmatch.pattern; _ } as untyped_case, case_data) -> + let htc = + with_local_level_if_principal begin fun () -> + let ty_arg = + (* propagation of pattern *) + with_local_level ~post:generalize_structure + (fun () -> instance ?partial:take_partial_instance ty_arg) + in + let (pat, ext_env, force, pvs, mvs) = + type_pattern category ~lev env pattern ty_arg allow_modules + in + pattern_force := force @ !pattern_force; + { typed_pat = pat; + pat_type_for_unif = ty_arg; + untyped_case; + case_data; + branch_env = ext_env; + pat_vars = pvs; + module_vars = mvs; + contains_gadt = contains_gadt (as_comp_pattern category pat); + } + end + ~post: begin fun htc -> + iter_pattern_variables_type generalize_structure htc.pat_vars; + end + in + (* Ensure that no ambivalent pattern type escapes its branch *) + check_scope_escape htc.typed_pat.pat_loc env outer_level + htc.pat_type_for_unif; + let pat = htc.typed_pat in + {htc with typed_pat = { pat with pat_type = instance pat.pat_type }} ) - caselist in - let patl = List.map (fun { typed_pat; _ } -> typed_pat) half_typed_cases in - let does_contain_gadt = - List.exists (fun { contains_gadt; _ } -> contains_gadt) half_typed_cases - in - let ty_res, do_copy_types = - if does_contain_gadt && not !Clflags.principal then - correct_levels ty_res, Env.make_copy_of_types env - else ty_res, (fun env -> env) - in - (* Unify all cases (delayed to keep it order-free) *) - let ty_arg' = newvar () in - let unify_pats ty = - List.iter (fun { typed_pat = pat; pat_type_for_unif = pat_ty; _ } -> - unify_pat_types pat.pat_loc (ref env) pat_ty ty - ) half_typed_cases + caselist in + let patl = + List.map (fun { typed_pat; _ } -> typed_pat) half_typed_cases in + let does_contain_gadt = + List.exists (fun { contains_gadt; _ } -> contains_gadt) half_typed_cases + in + let ty_res, do_copy_types = + if does_contain_gadt && not !Clflags.principal then + correct_levels ty_res, Env.make_copy_of_types env + else ty_res, (fun env -> env) + in + (* Unify all cases (delayed to keep it order-free) *) + let ty_arg' = newvar () in + let unify_pats ty = + List.iter (fun { typed_pat = pat; pat_type_for_unif = pat_ty; _ } -> + unify_pat_types pat.pat_loc env pat_ty ty + ) half_typed_cases + in + unify_pats ty_arg'; + (* Check for polymorphic variants to close *) + if List.exists has_variants patl then begin + Parmatch.pressure_variants_in_computation_pattern env + (List.map (as_comp_pattern category) patl); + List.iter finalize_variants patl + end; + (* `Contaminating' unifications start here *) + List.iter (fun f -> f()) !pattern_force; + (* Post-processing and generalization *) + if take_partial_instance <> None then unify_pats (instance ty_arg); + List.iter (fun { pat_vars; _ } -> + iter_pattern_variables_type (enforce_current_level env) pat_vars + ) half_typed_cases; + (half_typed_cases, ty_res, do_copy_types, ty_arg') + end + ~post: begin fun (half_typed_cases, _, _, ty_arg') -> + generalize ty_arg'; + List.iter (fun { pat_vars; _ } -> + iter_pattern_variables_type generalize pat_vars + ) half_typed_cases + end in - unify_pats ty_arg'; - (* Check for polymorphic variants to close *) - if List.exists has_variants patl then begin - Parmatch.pressure_variants_in_computation_pattern env - (List.map (as_comp_pattern category) patl); - List.iter finalize_variants patl - end; - (* `Contaminating' unifications start here *) - List.iter (fun f -> f()) !pattern_force; - (* Post-processing and generalization *) - if take_partial_instance <> None then unify_pats (instance ty_arg); - List.iter (fun { pat_vars; _ } -> - iter_pattern_variables_type (fun t -> unify_var env (newvar()) t) pat_vars - ) half_typed_cases; - end_def (); - generalize ty_arg'; - List.iter (fun { pat_vars; _ } -> - iter_pattern_variables_type generalize pat_vars - ) half_typed_cases; (* type bodies *) - let in_function = if List.length caselist = 1 then in_function else None in - let cases = + let ty_res' = instance ty_res in + let result = with_local_level_if_principal ~post:ignore begin fun () -> List.map - (fun { typed_pat = pat; branch_env = ext_env; pat_vars = pvs; unpacks; - untyped_case = {pc_lhs = _; pc_guard; pc_rhs}; - contains_gadt; _ } -> + (fun { typed_pat = pat; branch_env = ext_env; + pat_vars = pvs; module_vars = mvs; + case_data; contains_gadt; _ } + -> let ext_env = if contains_gadt then do_copy_types ext_env else ext_env in + (* Before handing off the cases to the callback, first set up the the + branch environments by adding the variables (and module variables) + from the patterns. + *) let ext_env = add_pattern_variables ext_env pvs ~check:(fun s -> Warnings.Unused_var_strict s) ~check_as:(fun s -> Warnings.Unused_var s) in - let unpacks = - List.map (fun (name, loc) -> - {tu_name = name; tu_loc = loc; - tu_uid = Uid.mk ~current_unit:(Env.get_unit_name ())} - ) unpacks - in - let ty_res' = - if !Clflags.principal then begin - begin_def (); - let ty = instance ~partial:true ty_res in - end_def (); - generalize_structure ty; ty - end - else if contains_gadt then - (* allow propagation from preceding branches *) + let ext_env = add_module_variables ext_env mvs in + let ty_expected = + if contains_gadt && not !Clflags.principal then + (* Take a generic copy of [ty_res] again to allow propagation of + type information from preceding branches *) correct_levels ty_res else ty_res in - let guard = - match pc_guard with - | None -> None - | Some scond -> - Some - (type_unpacks ext_env unpacks scond - (mk_expected ~explanation:When_guard Predef.type_bool)) - in - let exp = - type_unpacks ?in_function ext_env - unpacks pc_rhs (mk_expected ?explanation ty_res') - in - { - c_lhs = pat; - c_guard = guard; - c_rhs = {exp with exp_type = instance ty_res'} - } - ) - half_typed_cases - in - if !Clflags.principal || does_contain_gadt then begin - let ty_res' = instance ty_res in - List.iter (fun c -> unify_exp env c.c_rhs ty_res') cases - end; + type_body case_data pat ~ext_env ~ty_expected ~ty_infer:ty_res' + ~contains_gadt) + half_typed_cases + end in let do_init = may_contain_gadts || needs_exhaust_check in let ty_arg_check = if do_init then @@ -5279,14 +5959,36 @@ and type_cases Subst.type_expr (Subst.for_saving Subst.identity) ty_arg' else ty_arg' in - let val_cases, exn_cases = + (* Split the cases into val and exn cases so we can do the appropriate checks + for exhaustivity and unused variables. + + The caller of this function can define custom checks. For some of these + checks, the half-typed case doesn't provide enough info on its own -- for + instance, the check for ambiguous bindings in when guards needs to know the + case body's expression -- so the code pairs each case with its + corresponding element in [result] before handing it off to the caller's + custom checks. + *) + let val_cases_with_result, exn_cases_with_result = match category with - | Value -> (cases : value case list), [] - | Computation -> split_cases env cases in + | Value -> + let val_cases = + List.map2 + (fun htc res -> + { htc.untyped_case with pattern = htc.typed_pat }, res) + half_typed_cases + result + in + (val_cases : (pattern Parmatch.parmatch_case * ret) list), [] + | Computation -> + split_half_typed_cases env (List.combine half_typed_cases result) + in + let val_cases = List.map fst val_cases_with_result in + let exn_cases = List.map fst exn_cases_with_result in if val_cases = [] && exn_cases <> [] then raise (error (loc, env, No_value_clauses)); let partial = - if partial_flag then + if check_if_total then check_partial ~lev env ty_arg_check loc val_cases else Partial @@ -5295,12 +5997,10 @@ and type_cases List.iter (fun { typed_pat; branch_env; _ } -> check_absent_variant branch_env (as_comp_pattern category typed_pat) ) half_typed_cases; - if delayed then (begin_def (); init_def lev); - check_unused ~lev env ty_arg_check val_cases ; - check_unused ~lev env Predef.type_exn exn_cases ; - if delayed then end_def (); - Parmatch.check_ambiguous_bindings val_cases ; - Parmatch.check_ambiguous_bindings exn_cases + with_level_if delayed ~level:lev begin fun () -> + check_unused ~lev env ty_arg_check val_cases ; + check_unused ~lev env Predef.type_exn exn_cases ; + end; in if not !has_errors then ( if contains_polyvars then @@ -5309,24 +6009,259 @@ and type_cases (* Check for unused cases, do not delay because of gadts *) unused_check false ); - if may_contain_gadts then begin - end_def (); - (* Ensure that existential types do not escape *) - unify_exp_types loc env (instance ty_res) (newvar ()) ; + begin + match additional_checks_for_split_cases with + | None -> () + | Some check -> + check val_cases_with_result; + check exn_cases_with_result; end; - cases, partial + (result, partial), [ty_res'] + end + (* Ensure that existential types do not escape *) + ~post:(fun ty_res' -> unify_exp_types loc env ty_res' (newvar ())) + +(* Typing of match cases *) +and type_cases + : type k . k pattern_category -> + _ -> _ -> _ -> check_if_total:bool -> _ -> Parsetree.case list -> + k case list * partial + = fun category env + ty_arg ty_res_explained ~check_if_total loc caselist -> + let { ty = ty_res; explanation } = ty_res_explained in + let caselist = + List.map (fun case -> Parmatch.untyped_case case, case) caselist + in + (* Most of the work is done by [map_half_typed_cases]. All that's left + is to typecheck the guards and the cases, and then to check for some + warnings that can fire in the presence of guards. + *) + map_half_typed_cases category env ty_arg ty_res loc caselist ~check_if_total + ~type_body:begin + fun { pc_guard; pc_rhs } pat ~ext_env ~ty_expected ~ty_infer + ~contains_gadt:_ -> + let guard = + match pc_guard with + | None -> None + | Some scond -> + Some + (type_expect ext_env scond + (mk_expected ~explanation:When_guard Predef.type_bool)) + in + let exp = + type_expect ext_env pc_rhs (mk_expected ?explanation ty_expected) + in + { + c_lhs = pat; + c_guard = guard; + c_rhs = {exp with exp_type = ty_infer} + } + end + ~additional_checks_for_split_cases:(fun cases -> + let cases = + List.map + (fun (case_with_pat, case) -> + { case with c_lhs = case_with_pat.Parmatch.pattern }) cases + in + Parmatch.check_ambiguous_bindings cases) + + +(** A version of [type_expect], but that operates over function cases instead + of expressions. The input type is like the [ty_expected] argument to + [type_expect], and the returned type is like the [exp_type] of the + expression returned by [type_expect]. + + See [split_function_ty] for the meaning of [first] and [in_function]. +*) +and type_function_cases_expect + env ty_expected loc cases attrs ~first ~in_function = + Builtin_attributes.warning_scope attrs begin fun () -> + let ty_arg, ty_res = + split_function_ty env ty_expected ~arg_label:Nolabel ~first ~in_function + in + let cases, partial = + type_cases Value env ty_arg (mk_expected ty_res) + ~check_if_total:true loc cases + in + let ty_fun = + instance (newgenty (Tarrow (Nolabel, ty_arg, ty_res, commu_ok))) + in + (try unify_exp_types loc env ty_fun (instance ty_expected); + with _ -> Msupport.erroneous_type_register ty_expected); + cases, partial, ty_fun + end (* Typing of let bindings *) -and type_let +and type_let ?check ?check_strict + existential_context env rec_flag spat_sexp_list allow_modules = + let spatl = List.map vb_pat_constraint spat_sexp_list in + let attrs_list = List.map fst spatl in + let is_recursive = (rec_flag = Recursive) in + + let (pat_list, exp_list, new_env, mvs, _pvs) = + with_local_level begin fun () -> + if existential_context = At_toplevel then Typetexp.TyVarEnv.reset (); + let (pat_list, new_env, force, pvs, mvs) = + with_local_level_if_principal begin fun () -> + let nvs = List.map (fun _ -> newvar ()) spatl in + let (pat_list, _new_env, _force, _pvs, _mvs as res) = + type_pattern_list + Value existential_context env spatl nvs allow_modules in + (* If recursive, first unify with an approximation of the + expression *) + if is_recursive then + List.iter2 + (fun pat binding -> + let pat = + match get_desc pat.pat_type with + | Tpoly (ty, tl) -> + {pat with pat_type = + snd (instance_poly ~keep_names:true ~fixed:false tl ty)} + | _ -> pat + in + let bound_expr = vb_exp_constraint binding in + unify_pat env pat (type_approx env bound_expr)) + pat_list spat_sexp_list; + (* Polymorphic variant processing *) + List.iter + (fun pat -> + if has_variants pat then begin + Parmatch.pressure_variants env [pat]; + finalize_variants pat + end) + pat_list; + res + end + ~post: begin fun (pat_list, _, _, pvs, _) -> + (* Generalize the structure *) + iter_pattern_variables_type generalize_structure pvs; + List.iter (fun pat -> generalize_structure pat.pat_type) pat_list + end + in + (* Note [add_module_variables after checking expressions] + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + Don't call [add_module_variables] here, because its use of + [type_module] will fail until after we have type-checked the expression + of the let. Example: [let m : (module S) = ... in let (module M) = m in + ...] We learn the signature [S] from the type of [m] in the RHS of the + second let, and we need that knowledge for [type_module] to succeed. If + we type-checked expressions before patterns, then we could call + [add_module_variables] here. + *) + let new_env = add_pattern_variables new_env pvs in + let pat_list = + List.map + (fun pat -> {pat with pat_type = instance pat.pat_type}) + pat_list + in + (* Only bind pattern variables after generalizing *) + List.iter (fun f -> f()) force; + + let exp_list = + (* See Note [add_module_variables after checking expressions] + We can't defer type-checking module variables with recursive + definitions, so things like [let rec (module M) = m in ...] always + fail, even if the type of [m] is known. + *) + let exp_env = + if is_recursive then add_module_variables new_env mvs else env + in + type_let_def_wrap_warnings ?check ?check_strict ~is_recursive + ~exp_env ~new_env ~spat_sexp_list ~attrs_list ~pat_list ~pvs + (fun exp_env ({pvb_attributes; _} as vb) pat -> + let sexp = vb_exp_constraint vb in + match get_desc pat.pat_type with + | Tpoly (ty, tl) -> + let vars, ty' = + with_local_level_if_principal + ~post:(fun (_,ty') -> generalize_structure ty') + (fun () -> instance_poly ~keep_names:true ~fixed:true tl ty) + in + let exp = + Builtin_attributes.warning_scope pvb_attributes (fun () -> + type_expect exp_env sexp (mk_expected ty')) + in + exp, Some vars + | _ -> + let exp = + Builtin_attributes.warning_scope pvb_attributes (fun () -> + type_expect exp_env sexp (mk_expected pat.pat_type)) + in + exp, None) + in + List.iter2 + (fun pat (attrs, exp) -> + Builtin_attributes.warning_scope ~ppwarning:false attrs + (fun () -> + let case = Parmatch.typed_case (case pat exp) in + ignore(check_partial env pat.pat_type pat.pat_loc + [case] : Typedtree.partial) + ) + ) + pat_list + (List.map2 (fun (attrs, _) (e, _) -> attrs, e) spatl exp_list); + (pat_list, exp_list, new_env, mvs, + List.map (fun pv -> { pv with pv_type = instance pv.pv_type}) pvs) + end + ~post: begin fun (pat_list, exp_list, _, _, pvs) -> + List.iter2 + (fun pat (exp, _) -> + if maybe_expansive exp then lower_contravariant env pat.pat_type) + pat_list exp_list; + iter_pattern_variables_type generalize pvs; + List.iter2 + (fun pat (exp, vars) -> + match vars with + | None -> + (* We generalize expressions even if they are not bound to a variable + and do not have an expliclit polymorphic type annotation. This is + not needed in general, however those types may be shown by the + interactive toplevel, for example: + {[ + let _ = Array.get;; + - : 'a array -> int -> 'a = + ]} + so we do it anyway. *) + generalize exp.exp_type + | Some vars -> + if maybe_expansive exp then + lower_contravariant env exp.exp_type; + generalize_and_check_univars env "definition" + exp pat.pat_type vars) + pat_list exp_list + end + in + let l = List.combine pat_list exp_list in + let l = + List.map2 + (fun (p, (e, _)) pvb -> + (* vb_rec_kind will be computed later for recursive bindings *) + {vb_pat=p; vb_expr=e; vb_attributes=pvb.pvb_attributes; + vb_loc=pvb.pvb_loc; vb_rec_kind = Dynamic; + }) + l spat_sexp_list + in + if is_recursive then + List.iter + (fun {vb_pat=pat} -> match pat.pat_desc with + Tpat_var _ -> () + | Tpat_alias ({pat_desc=Tpat_any}, _, _, _) -> () + | _ -> raise(error(pat.pat_loc, env, Illegal_letrec_pat))) + l; + List.iter (fun vb -> + if pattern_needs_partial_application_check vb.vb_pat then + check_partial_application ~statement:false vb.vb_expr + ) l; + (* See Note [add_module_variables after checking expressions] *) + let new_env = add_module_variables new_env mvs in + (l, new_env) + +and type_let_def_wrap_warnings ?(check = fun s -> Warnings.Unused_var s) ?(check_strict = fun s -> Warnings.Unused_var_strict s) - existential_context - env rec_flag spat_sexp_list allow = - let open Ast_helper in - begin_def(); - if !Clflags.principal then begin_def (); - + ~is_recursive ~exp_env ~new_env ~spat_sexp_list ~attrs_list ~pat_list ~pvs + type_def = let is_fake_let = match spat_sexp_list with | [{pvb_expr={pexp_desc=Pexp_match( @@ -5336,71 +6271,21 @@ and type_let false in let check = if is_fake_let then check_strict else check in - - let spatl = - List.map - (fun {pvb_pat=spat; pvb_expr=sexp; pvb_attributes=attrs} -> - attrs, - match spat.ppat_desc, sexp.pexp_desc with - (Ppat_any | Ppat_constraint _), _ -> spat - | _, Pexp_coerce (_, _, sty) - | _, Pexp_constraint (_, sty) when !Clflags.principal -> - (* propagate type annotation to pattern, - to allow it to be generalized in -principal mode *) - Pat.constraint_ - ~loc:{spat.ppat_loc with Location.loc_ghost=true} - spat - sty - | _ -> spat) - spat_sexp_list in - let nvs = List.map (fun _ -> newvar ()) spatl in - let (pat_list, new_env, force, pvs, unpacks) = - type_pattern_list Value existential_context env spatl nvs allow in - let attrs_list = List.map fst spatl in - let is_recursive = (rec_flag = Recursive) in - (* If recursive, first unify with an approximation of the expression *) - if is_recursive then - List.iter2 - (fun pat binding -> - let pat = - match get_desc pat.pat_type with - | Tpoly (ty, tl) -> - {pat with pat_type = - snd (instance_poly ~keep_names:true false tl ty)} - | _ -> pat - in unify_pat (ref env) pat (type_approx env binding.pvb_expr)) - pat_list spat_sexp_list; - (* Polymorphic variant processing *) - List.iter - (fun pat -> - if has_variants pat then begin - Parmatch.pressure_variants env [pat]; - finalize_variants pat - end) - pat_list; - (* Generalize the structure *) - let pat_list = - if !Clflags.principal then begin - end_def (); - iter_pattern_variables_type generalize_structure pvs; - List.map (fun pat -> - generalize_structure pat.pat_type; - {pat with pat_type = instance pat.pat_type} - ) pat_list - end else - pat_list + let warn_about_unused_bindings = + List.exists + (fun attrs -> + Builtin_attributes.warning_scope ~ppwarning:false attrs (fun () -> + Warnings.is_active (check "") || Warnings.is_active (check_strict "") + || (is_recursive && (Warnings.is_active Warnings.Unused_rec_flag)))) + attrs_list in - (* Only bind pattern variables after generalizing *) - List.iter (fun f -> f()) force; let sexp_is_fun { pvb_expr = sexp; _ } = match sexp.pexp_desc with - | Pexp_fun _ | Pexp_function _ -> true + | Pexp_function _ -> true | _ -> false in let exp_env = - if is_recursive then new_env - else if List.for_all sexp_is_fun spat_sexp_list - then begin + if not is_recursive && List.for_all sexp_is_fun spat_sexp_list then begin (* Add ghost bindings to help detecting missing "rec" keywords. We only add those if the body of the definition is obviously a @@ -5412,109 +6297,78 @@ and type_let a let .. and ..), and is where the missing "rec" hint suggests to add a "rec" keyword. *) match spat_sexp_list with - | {pvb_loc; _} :: _ -> maybe_add_pattern_variables_ghost pvb_loc env pvs + | {pvb_loc; _} :: _ -> + maybe_add_pattern_variables_ghost pvb_loc exp_env pvs | _ -> assert false end - else env in - + else exp_env + in + (* Algorithm to detect unused declarations in recursive bindings: + - During type checking of the definitions, we capture the 'value_used' + events on the bound identifiers and record them in a slot corresponding + to the current definition (!current_slot). + In effect, this creates a dependency graph between definitions. + + - After type checking the definition (!current_slot = None), + when one of the bound identifier is effectively used, we trigger + again all the events recorded in the corresponding slot. + The effect is to traverse the transitive closure of the graph created + in the first step. + + We also keep track of whether *all* variables in a given pattern + are unused. If this is the case, for local declarations, the issued + warning is 26, not 27. + *) let current_slot = ref None in let rec_needed = ref false in - let warn_about_unused_bindings = - List.exists - (fun attrs -> - Builtin_attributes.warning_scope ~ppwarning:false attrs (fun () -> - Warnings.is_active (check "") || Warnings.is_active (check_strict "") - || (is_recursive && (Warnings.is_active Warnings.Unused_rec_flag)))) - attrs_list - in let pat_slot_list = - (* Algorithm to detect unused declarations in recursive bindings: - - During type checking of the definitions, we capture the 'value_used' - events on the bound identifiers and record them in a slot corresponding - to the current definition (!current_slot). - In effect, this creates a dependency graph between definitions. - - - After type checking the definition (!current_slot = None), - when one of the bound identifier is effectively used, we trigger - again all the events recorded in the corresponding slot. - The effect is to traverse the transitive closure of the graph created - in the first step. - - We also keep track of whether *all* variables in a given pattern - are unused. If this is the case, for local declarations, the issued - warning is 26, not 27. - *) List.map2 (fun attrs pat -> - Builtin_attributes.warning_scope ~ppwarning:false attrs (fun () -> - if not warn_about_unused_bindings then pat, None - else - let some_used = ref false in - (* has one of the identifier of this pattern been used? *) - let slot = ref [] in - List.iter - (fun id -> - let vd = Env.find_value (Path.Pident id) new_env in - (* note: Env.find_value does not trigger the value_used - event *) - let name = Ident.name id in - let used = ref false in - if not (name = "" || name.[0] = '_' || name.[0] = '#') then - add_delayed_check - (fun () -> - if not !used then - Location.prerr_warning vd.Types.val_loc - ((if !some_used then check_strict else check) name) - ); - Env.set_value_used_callback - vd + Builtin_attributes.warning_scope ~ppwarning:false attrs (fun () -> + if not warn_about_unused_bindings then pat, None + else + let some_used = ref false in + (* has one of the identifier of this pattern been used? *) + let slot = ref [] in + List.iter + (fun id -> + let vd = Env.find_value (Path.Pident id) new_env in + (* note: Env.find_value does not trigger the value_used + event *) + let name = Ident.name id in + let used = ref false in + if not (name = "" || name.[0] = '_' || name.[0] = '#') then + add_delayed_check (fun () -> - match !current_slot with - | Some slot -> - slot := vd.val_uid :: !slot; rec_needed := true - | None -> - List.iter Env.mark_value_used (get_ref slot); - used := true; - some_used := true - ) - ) - (Typedtree.pat_bound_idents pat); - pat, Some slot - )) + if not !used then + Location.prerr_warning vd.Types.val_loc + ((if !some_used then check_strict else check) name) + ); + Env.set_value_used_callback + vd + (fun () -> + match !current_slot with + | Some slot -> + slot := vd.val_uid :: !slot; rec_needed := true + | None -> + List.iter Env.mark_value_used (get_ref slot); + used := true; + some_used := true + ) + ) + (Typedtree.pat_bound_idents pat); + pat, Some slot + )) attrs_list pat_list in let exp_list = List.map2 - (fun {pvb_expr=sexp; pvb_attributes; _} (pat, slot) -> + (fun case (pat, slot) -> if is_recursive then current_slot := slot; - match get_desc pat.pat_type with - | Tpoly (ty, tl) -> - if !Clflags.principal then begin_def (); - let vars, ty' = instance_poly ~keep_names:true true tl ty in - if !Clflags.principal then begin - end_def (); - generalize_structure ty' - end; - let exp = - Builtin_attributes.warning_scope pvb_attributes (fun () -> - if rec_flag = Recursive then - type_unpacks exp_env unpacks sexp (mk_expected ty') - else - type_expect exp_env sexp (mk_expected ty') - ) - in - exp, Some vars - | _ -> - let exp = - Builtin_attributes.warning_scope pvb_attributes (fun () -> - if rec_flag = Recursive then - type_unpacks exp_env unpacks sexp (mk_expected pat.pat_type) - else - type_expect exp_env sexp (mk_expected pat.pat_type)) - in - exp, None) - spat_sexp_list pat_slot_list in + type_def exp_env case pat) + spat_sexp_list pat_slot_list + in current_slot := None; if is_recursive && not !rec_needed then begin let {pvb_pat; pvb_attributes} = List.hd spat_sexp_list in @@ -5524,92 +6378,34 @@ and type_let Location.prerr_warning pvb_pat.ppat_loc Warnings.Unused_rec_flag ) end; - List.iter2 - (fun pat (attrs, exp) -> - Builtin_attributes.warning_scope ~ppwarning:false attrs - (fun () -> - ignore(check_partial env pat.pat_type pat.pat_loc - [case pat exp]) - ) - ) - pat_list - (List.map2 (fun (attrs, _) (e, _) -> attrs, e) spatl exp_list); - let pvs = List.map (fun pv -> { pv with pv_type = instance pv.pv_type}) pvs in - end_def(); - List.iter2 - (fun pat (exp, _) -> - if maybe_expansive exp then - lower_contravariant env pat.pat_type) - pat_list exp_list; - iter_pattern_variables_type generalize pvs; - List.iter2 - (fun pat (exp, vars) -> - match vars with - | None -> - (* We generalize expressions even if they are not bound to a variable - and do not have an expliclit polymorphic type annotation. This is - not needed in general, however those types may be shown by the - interactive toplevel, for example: - {[ - let _ = Array.get;; - - : 'a array -> int -> 'a = - ]} - so we do it anyway. *) - generalize exp.exp_type - | Some vars -> - if maybe_expansive exp then - lower_contravariant env exp.exp_type; - generalize_and_check_univars env "definition" exp pat.pat_type vars) - pat_list exp_list; - let l = List.combine pat_list exp_list in - let l = - List.map2 - (fun (p, (e, _)) pvb -> - {vb_pat=p; vb_expr=e; vb_attributes=pvb.pvb_attributes; - vb_loc=pvb.pvb_loc; - }) - l spat_sexp_list - in - if is_recursive then - List.iter - (fun {vb_pat=pat} -> match pat.pat_desc with - Tpat_var _ -> () - | Tpat_alias ({pat_desc=Tpat_any}, _, _) -> () - | _ -> raise(error(pat.pat_loc, env, Illegal_letrec_pat))) - l; - List.iter (function - | {vb_pat = {pat_desc = Tpat_any; pat_extra; _}; vb_expr; _} -> - if not (List.exists (function (Tpat_constraint _, _, _) -> true - | _ -> false) pat_extra) then - check_partial_application ~statement:false vb_expr - | _ -> ()) l; - (l, new_env, unpacks) + exp_list and type_andops env sarg sands expected_ty = let rec loop env let_sarg rev_sands expected_ty = match rev_sands with | [] -> type_expect env let_sarg (mk_expected expected_ty), [] | { pbop_op = sop; pbop_exp = sexp; pbop_loc = loc; _ } :: rest -> - if !Clflags.principal then begin_def (); - let op_path, op_desc = type_binding_op_ident env sop in - let op_type = instance op_desc.val_type in - let ty_arg = newvar () in - let ty_rest = newvar () in - let ty_result = newvar() in - let ty_rest_fun = - newty (Tarrow(Nolabel, ty_arg, ty_result, commu_ok)) in - let ty_op = newty (Tarrow(Nolabel, ty_rest, ty_rest_fun, commu_ok)) in - begin try - unify env op_type ty_op - with Unify err -> - raise(error(sop.loc, env, Andop_type_clash(sop.txt, err))) - end; - if !Clflags.principal then begin - end_def (); - generalize_structure ty_rest; - generalize_structure ty_arg; - generalize_structure ty_result - end; + let op_path, op_desc, op_type, ty_arg, ty_rest, ty_result = + with_local_level_iter_if_principal begin fun () -> + let op_path, op_desc = type_binding_op_ident env sop in + let op_type = instance op_desc.val_type in + let ty_arg = newvar () in + let ty_rest = newvar () in + let ty_result = newvar() in + let ty_rest_fun = + newty (Tarrow(Nolabel, ty_arg, ty_result, commu_ok)) in + let ty_op = + newty (Tarrow(Nolabel, ty_rest, ty_rest_fun, commu_ok)) in + begin try + unify env op_type ty_op + with Unify err -> + raise(error(sop.loc, env, Andop_type_clash(sop.txt, err))) + end; + ((op_path, op_desc, op_type, ty_arg, ty_rest, ty_result), + [ty_rest; ty_arg; ty_result]) + end + ~post:generalize_structure + in let let_arg, rest = loop env let_sarg rest ty_rest in let exp = type_expect env sexp (mk_expected ty_arg) in begin try @@ -5630,33 +6426,116 @@ and type_andops env sarg sands expected_ty = let let_arg, rev_ands = loop env sarg (List.rev sands) expected_ty in let_arg, List.rev rev_ands +(* Typing of method call *) +and type_send env loc explanation e met = + let obj = type_exp env e in + let (meth, typ) = + match obj.exp_desc with + | Texp_ident(_, _, {val_kind = Val_self(sign, meths, _, _)}) -> + let id, typ = + match meths with + | Self_concrete meths -> + let id = + match Meths.find met meths with + | id -> id + | exception Not_found -> + let valid_methods = + Meths.fold (fun lab _ acc -> lab :: acc) meths [] + in + raise (error(e.pexp_loc, env, + Undefined_self_method (met, valid_methods))) + in + let typ = Btype.method_type met sign in + id, typ + | Self_virtual meths_ref -> begin + match Meths.find met !meths_ref with + | id -> id, Btype.method_type met sign + | exception Not_found -> + let id = Ident.create_local met in + let ty = newvar () in + meths_ref := Meths.add met id !meths_ref; + add_method env met Private Virtual ty sign; + Location.prerr_warning loc + (Warnings.Undeclared_virtual_method met); + id, ty + end + in + Tmeth_val id, typ + | Texp_ident(_, _, {val_kind = Val_anc (sign, meths, cl_num)}) -> + let id = + match Meths.find met meths with + | id -> id + | exception Not_found -> + let valid_methods = + Meths.fold (fun lab _ acc -> lab :: acc) meths [] + in + raise (error(e.pexp_loc, env, + Undefined_self_method (met, valid_methods))) + in + let typ = Btype.method_type met sign in + let (self_path, _) = + Env.find_value_by_name + (Longident.Lident ("self-" ^ cl_num)) env + in + Tmeth_ancestor(id, self_path), typ + | _ -> + let ty = + match filter_method env met obj.exp_type with + | ty -> ty + | exception Filter_method_failed err -> + let error_ = + match err with + | Unification_error err -> + Expr_type_clash(err, explanation, None) + | Not_an_object ty -> + Not_an_object(ty, explanation) + | Not_a_method -> + let valid_methods = + match get_desc (expand_head env obj.exp_type) with + | Tobject (fields, _) -> + let (fields, _) = Ctype.flatten_fields fields in + let collect_fields li (meth, meth_kind, _meth_ty) = + if field_kind_repr meth_kind = Fpublic + then meth::li else li + in + Some (List.fold_left collect_fields [] fields) + | _ -> None + in + Undefined_method(obj.exp_type, met, valid_methods) + in + raise (error(e.pexp_loc, env, error_)) + in + Tmeth_name met, ty + in + (obj,meth,typ) + (* Typing of toplevel bindings *) let type_binding env rec_flag spat_sexp_list = - Typetexp.reset_type_variables(); - let (pat_exp_list, new_env, _unpacks) = + let (pat_exp_list, new_env) = type_let ~check:(fun s -> Warnings.Unused_value_declaration s) ~check_strict:(fun s -> Warnings.Unused_value_declaration s) At_toplevel - env rec_flag spat_sexp_list false + env rec_flag spat_sexp_list Modules_rejected in (pat_exp_list, new_env) let type_let existential_ctx env rec_flag spat_sexp_list = - let (pat_exp_list, new_env, _unpacks) = - type_let existential_ctx env rec_flag spat_sexp_list false in + let (pat_exp_list, new_env) = + type_let existential_ctx env rec_flag spat_sexp_list Modules_rejected in (pat_exp_list, new_env) (* Typing of toplevel expressions *) let type_expression env sexp = - Typetexp.reset_type_variables(); - begin_def(); - let exp = type_exp env sexp in - end_def(); - if maybe_expansive exp then lower_contravariant env exp.exp_type; - generalize exp.exp_type; + let exp = + with_local_level begin fun () -> + Typetexp.TyVarEnv.reset(); + type_exp env sexp + end + ~post:(may_lower_contravariant_then_generalize env) + in match sexp.pexp_desc with Pexp_ident lid -> let loc = sexp.pexp_loc in @@ -5691,10 +6570,7 @@ let type_clash_of_trace trace = and when the expected type is `int` *) let report_literal_type_constraint expected_type const = let const_str = match const with - | Const_int n -> Some (Int.to_string n) - | Const_int32 n -> Some (Int32.to_string n) - | Const_int64 n -> Some (Int64.to_string n) - | Const_nativeint n -> Some (Nativeint.to_string n) + | Pconst_integer (s, _) -> Some s | _ -> None in let suffix = @@ -5708,8 +6584,13 @@ let report_literal_type_constraint expected_type const = Some '.' else None in + let pp_const ppf (c,s) = Format.fprintf ppf "%s%c" c s in match const_str, suffix with - | Some c, Some s -> [ Location.msg "@[Hint: Did you mean `%s%c'?@]" c s ] + | Some c, Some s -> [ + Location.msg + "@[@{Hint@}: Did you mean %a?@]" + (Style.as_inline_code pp_const) (c,s) + ] | _, _ -> [] let report_literal_type_constraint const = function @@ -5721,15 +6602,26 @@ let report_literal_type_constraint const = function end | None -> [] +let report_partial_application = function + | Some tr -> begin + match get_desc tr.Errortrace.got.Errortrace.expanded with + | Tarrow _ -> + [ Location.msg + "@[@{Hint@}: This function application is partial,@ \ + maybe some arguments are missing.@]" ] + | _ -> [] + end + | None -> [] + let report_expr_type_clash_hints exp diff = match exp with - | Some (Texp_constant const) -> report_literal_type_constraint const diff + | Some (Pexp_constant const) -> report_literal_type_constraint const diff + | Some (Pexp_apply _) -> report_partial_application diff | _ -> [] -let report_pattern_type_clash_hints - (type k) (pat : k pattern_desc option) diff = +let report_pattern_type_clash_hints pat diff = match pat with - | Some (Tpat_constant const) -> report_literal_type_constraint const diff + | Some (Ppat_constant const) -> report_literal_type_constraint const diff | _ -> [] let report_type_expected_explanation expl ppf = @@ -5768,17 +6660,54 @@ let report_unification_error ~loc ?sub env err ?type_expected_explanation txt1 txt2 ) () +let report_this_function ppf funct = + if Typedtree.exp_is_nominal funct then + let pexp = Untypeast.untype_expression funct in + Format.fprintf ppf "The function %a" + (Style.as_inline_code Pprintast.expression) pexp + else Format.fprintf ppf "This function" + +let report_too_many_arg_error ~funct ~func_ty ~previous_arg_loc + ~extra_arg_loc ~returns_unit loc = + let open Location in + let cnum_offset off (pos : Lexing.position) = + { pos with pos_cnum = pos.pos_cnum + off } + in + let app_loc = + (* Span the application, including the extra argument. *) + { loc_start = loc.loc_start; + loc_end = extra_arg_loc.loc_end; + loc_ghost = false } + and tail_loc = + (* Possible location for a ';'. The location is widened to overlap the end + of the argument. *) + let arg_end = previous_arg_loc.loc_end in + { loc_start = cnum_offset ~-1 arg_end; + loc_end = cnum_offset ~+1 arg_end; + loc_ghost = false } + in + let hint_semicolon = if returns_unit then [ + msg ~loc:tail_loc "@{Hint@}: Did you forget a ';'?"; + ] else [] in + let sub = hint_semicolon @ [ + msg ~loc:extra_arg_loc "This extra argument is not expected."; + ] in + errorf ~loc:app_loc ~sub + "@[@[<2>%a has type@ %a@]\ + @ It is applied to too many arguments@]" + report_this_function funct Printtyp.type_expr func_ty + let report_error ~loc env = function | Constructor_arity_mismatch(lid, expected, provided) -> Location.errorf ~loc "@[The constructor %a@ expects %i argument(s),@ \ but is applied here to %i argument(s)@]" - longident lid expected provided + (Style.as_inline_code longident) lid expected provided | Label_mismatch(lid, err) -> report_unification_error ~loc env err (function ppf -> fprintf ppf "The record field %a@ belongs to the type" - longident lid) + (Style.as_inline_code longident) lid) (function ppf -> fprintf ppf "but is mixed here with fields of type") | Pattern_type_clash (err, pat) -> @@ -5793,19 +6722,21 @@ let report_error ~loc env = function | Or_pattern_type_clash (id, err) -> report_unification_error ~loc env err (function ppf -> - fprintf ppf "The variable %s on the left-hand side of this \ - or-pattern has type" (Ident.name id)) + fprintf ppf "The variable %a on the left-hand side of this \ + or-pattern has type" Style.inline_code (Ident.name id)) (function ppf -> fprintf ppf "but on the right-hand side it has type") | Multiply_bound_variable name -> Location.errorf ~loc - "Variable %s is bound several times in this matching" - name + "Variable %a is bound several times in this matching" + Style.inline_code name | Orpat_vars (id, valid_idents) -> Location.error_of_printer ~loc (fun ppf () -> fprintf ppf - "Variable %s must occur on both sides of this | pattern" - (Ident.name id); + "Variable %a must occur on both sides of this %a pattern" + Style.inline_code (Ident.name id) + Style.inline_code "|" + ; spellcheck_idents ppf id valid_idents ) () | Expr_type_clash (err, explanation, exp) -> @@ -5818,22 +6749,68 @@ let report_error ~loc env = function fprintf ppf "This expression has type") (function ppf -> fprintf ppf "but an expression was expected of type"); - | Apply_non_function typ -> - begin match get_desc typ with + | Function_arity_type_clash { + syntactic_arity; type_constraint; trace = { trace }; + } -> + (* The last diff's expected type will be the locally-abstract type + that the GADT pattern introduced an equation on. + *) + let type_with_local_equation = + let last_diff = + List.find_map + (function Errortrace.Diff diff -> Some diff | _ -> None) + (List.rev trace) + in + match last_diff with + | None -> None + | Some diff -> Some diff.expected.ty + in + (* [syntactic_arity>1] for this error, so "arguments" is always plural. *) + Location.errorf ~loc + "@[\ + @[\ + The syntactic arity of the function doesn't match the type constraint:@ \ + @[<2>\ + This function has %d syntactic arguments, but its type is constrained \ + to@ %a.\ + @]@ \ + @]@ \ + @[\ + @[<2>@{Hint@}: \ + consider splitting the function definition into@ %a@ \ + where %a is the pattern with the GADT constructor that@ \ + introduces the local type equation%t.\ + @]" + syntactic_arity + (Style.as_inline_code Printtyp.type_expr) type_constraint + Style.inline_code "fun ... gadt_pat -> fun ..." + Style.inline_code "gadt_pat" + (fun ppf -> + Option.iter + (fprintf ppf " on %a" (Style.as_inline_code Printtyp.type_expr)) + type_with_local_equation) + | Apply_non_function { + funct; func_ty; res_ty; previous_arg_loc; extra_arg_loc + } -> + begin match get_desc func_ty with Tarrow _ -> - Location.errorf ~loc - "@[@[<2>This function has type@ %a@]\ - @ @[It is applied to too many arguments;@ %s@]@]" - Printtyp.type_expr typ "maybe you forgot a `;'."; + let returns_unit = match get_desc res_ty with + | Tconstr (p, _, _) -> Path.same p Predef.path_unit + | _ -> false + in + report_too_many_arg_error ~funct ~func_ty ~previous_arg_loc + ~extra_arg_loc ~returns_unit loc | _ -> Location.errorf ~loc "@[@[<2>This expression has type@ %a@]@ %s@]" - Printtyp.type_expr typ + (Style.as_inline_code Printtyp.type_expr) func_ty "This is not a function; it cannot be applied." end | Apply_wrong_label (l, ty, extra_info) -> let print_label ppf = function | Nolabel -> fprintf ppf "without label" - | l -> fprintf ppf "with label %s" (prefixed_label_name l) + | l -> + fprintf ppf "with label %a" + Style.inline_code (prefixed_label_name l) in let extra_info = if not extra_info then @@ -5851,30 +6828,32 @@ let report_error ~loc env = function Location.errorf ~loc "The record field label %s is defined several times" s | Label_missing labels -> - let print_labels ppf = - List.iter (fun lbl -> fprintf ppf "@ %s" (Ident.name lbl)) in + let print_label ppf lbl = Style.inline_code ppf (Ident.name lbl) in + let print_labels ppf = List.iter (fprintf ppf "@ %a" print_label) in Location.errorf ~loc "@[Some record fields are undefined:%a@]" print_labels labels | Label_not_mutable lid -> - Location.errorf ~loc "The record field %a is not mutable" longident lid + Location.errorf ~loc "The record field %a is not mutable" + (Style.as_inline_code longident) lid | Wrong_name (eorp, ty_expected, { type_path; kind; name; valid_names; }) -> Location.error_of_printer ~loc (fun ppf () -> Printtyp.wrap_printing_env ~error:true env (fun () -> let { ty; explanation } = ty_expected in if Path.is_constructor_typath type_path then begin fprintf ppf - "@[The field %s is not part of the record \ + "@[The field %a is not part of the record \ argument for the %a constructor@]" - name.txt - Printtyp.type_path type_path; + Style.inline_code name.txt + (Style.as_inline_code Printtyp.type_path) type_path; end else begin fprintf ppf "@[@[<2>%s type@ %a%t@]@ \ - There is no %s %s within type %a@]" - eorp Printtyp.type_expr ty + There is no %s %a within type %a@]" + eorp (Style.as_inline_code Printtyp.type_expr) ty (report_type_expected_explanation_opt explanation) (Datatype_kind.label_name kind) - name.txt (*kind*) Printtyp.type_path type_path; + Style.inline_code name.txt + (Style.as_inline_code Printtyp.type_path) type_path; end; spellcheck ppf name.txt valid_names )) () @@ -5885,10 +6864,11 @@ let report_error ~loc env = function Printtyp.report_ambiguous_type_error ppf env tp tpl (function ppf -> fprintf ppf "The %s %a@ belongs to the %s type" - name longident lid type_name) + name (Style.as_inline_code longident) lid + type_name) (function ppf -> fprintf ppf "The %s %a@ belongs to one of the following %s types:" - name longident lid type_name) + name (Style.as_inline_code longident) lid type_name) (function ppf -> fprintf ppf "but a %s was expected belonging to the %s type" name type_name) @@ -5899,7 +6879,7 @@ let report_error ~loc env = function Location.error_of_printer ~loc (fun ppf () -> fprintf ppf "This expression is not an object;@ \ it has type %a" - Printtyp.type_expr ty; + (Style.as_inline_code Printtyp.type_expr) ty; report_type_expected_explanation_opt explanation ppf ) () | Undefined_method (ty, me, valid_methods) -> @@ -5907,7 +6887,9 @@ let report_error ~loc env = function Printtyp.wrap_printing_env ~error:true env (fun () -> fprintf ppf "@[@[This expression has type@;<1 2>%a@]@,\ - It has no method %s@]" Printtyp.type_expr ty me; + It has no method %a@]" + (Style.as_inline_code Printtyp.type_expr) ty + Style.inline_code me; begin match valid_methods with | None -> () | Some valid_methods -> spellcheck ppf me valid_methods @@ -5915,19 +6897,20 @@ let report_error ~loc env = function )) () | Undefined_self_method (me, valid_methods) -> Location.error_of_printer ~loc (fun ppf () -> - fprintf ppf "This expression has no method %s" me; + fprintf ppf "This expression has no method %a" Style.inline_code me; spellcheck ppf me valid_methods; ) () | Virtual_class cl -> Location.errorf ~loc "Cannot instantiate the virtual class %a" - longident cl + (Style.as_inline_code longident) cl | Unbound_instance_variable (var, valid_vars) -> Location.error_of_printer ~loc (fun ppf () -> - fprintf ppf "Unbound instance variable %s" var; + fprintf ppf "Unbound instance variable %a" Style.inline_code var; spellcheck ppf var valid_vars; ) () | Instance_variable_not_mutable v -> - Location.errorf ~loc "The instance variable %s is not mutable" v + Location.errorf ~loc "The instance variable %a is not mutable" + Style.inline_code v | Not_subtype err -> Location.error_of_printer ~loc (fun ppf () -> Printtyp.Subtype.report_error ppf env err "is not a subtype of" @@ -5937,8 +6920,8 @@ let report_error ~loc env = function "This object duplication occurs outside a method definition" | Value_multiply_overridden v -> Location.errorf ~loc - "The instance variable %s is overridden several times" - v + "The instance variable %a is overridden several times" + Style.inline_code v | Coercion_failure (ty_exp, err, b) -> Location.error_of_printer ~loc (fun ppf () -> Printtyp.report_unification_error ppf env err @@ -5946,31 +6929,36 @@ let report_error ~loc env = function let ty_exp = Printtyp.prepare_expansion ty_exp in fprintf ppf "This expression cannot be coerced to type@;<1 2>%a;@ \ it has type" - (Printtyp.type_expansion Type) ty_exp) + (Style.as_inline_code @@ Printtyp.type_expansion Type) ty_exp) (function ppf -> fprintf ppf "but is here used with type"); if b then - fprintf ppf ".@.@[%s@ %s@ %s@]" - "This simple coercion was not fully general." - "Hint: Consider using a fully explicit coercion" - "of the form: `(foo : ty1 :> ty2)'." + fprintf ppf + ".@.@[This simple coercion was not fully general.@ \ + @{Hint@}: Consider using a fully explicit coercion@ \ + of the form: %a@]" + Style.inline_code "(foo : ty1 :> ty2)" ) () | Not_a_function (ty, explanation) -> Location.errorf ~loc "This expression should not be a function,@ \ the expected type is@ %a%t" - Printtyp.type_expr ty + (Style.as_inline_code Printtyp.type_expr) ty (report_type_expected_explanation_opt explanation) | Too_many_arguments (ty, explanation) -> Location.errorf ~loc "This function expects too many arguments,@ \ it should have type@ %a%t" - Printtyp.type_expr ty + (Style.as_inline_code Printtyp.type_expr) ty (report_type_expected_explanation_opt explanation) | Abstract_wrong_label {got; expected; expected_type; explanation} -> - let label ~long = function - | Nolabel -> "unlabeled" - | l -> (if long then "labeled " else "") ^ prefixed_label_name l + let label ~long ppf = function + | Nolabel -> fprintf ppf "unlabeled" + | l -> + if long then + fprintf ppf "labeled %a" Style.inline_code (prefixed_label_name l) + else + Style.inline_code ppf (prefixed_label_name l) in let second_long = match got, expected with | Nolabel, _ | _, Nolabel -> true @@ -5978,29 +6966,34 @@ let report_error ~loc env = function in Location.errorf ~loc "@[@[<2>This function should have type@ %a%t@]@,\ - @[but its first argument is %s@ instead of %s%s@]@]" - Printtyp.type_expr expected_type + @[but its first argument is %a@ instead of %s%a@]@]" + (Style.as_inline_code Printtyp.type_expr) expected_type (report_type_expected_explanation_opt explanation) - (label ~long:true got) + (label ~long:true) got (if second_long then "being " else "") - (label ~long:second_long expected) + (label ~long:second_long) expected | Scoping_let_module(id, ty) -> Location.errorf ~loc - "This `let module' expression has type@ %a@ \ - In this type, the locally bound module name %s escapes its scope" - Printtyp.type_expr ty id + "This %a expression has type@ %a@ \ + In this type, the locally bound module name %a escapes its scope" + Style.inline_code "let module" + (Style.as_inline_code Printtyp.type_expr) ty + Style.inline_code id | Private_type ty -> Location.errorf ~loc "Cannot create values of the private type %a" - Printtyp.type_expr ty + (Style.as_inline_code Printtyp.type_expr) ty | Private_label (lid, ty) -> Location.errorf ~loc "Cannot assign field %a of the private type %a" - longident lid Printtyp.type_expr ty + (Style.as_inline_code longident) lid + (Style.as_inline_code Printtyp.type_expr) ty | Private_constructor (constr, ty) -> Location.errorf ~loc - "Cannot use private constructor %s to create values of type %a" - constr.cstr_name Printtyp.type_expr ty + "Cannot use private constructor %a to create values of type %a" + Style.inline_code constr.cstr_name + (Style.as_inline_code Printtyp.type_expr) ty | Not_a_polymorphic_variant_type lid -> - Location.errorf ~loc "The type %a@ is not a variant type" longident lid + Location.errorf ~loc "The type %a@ is not a variant type" + (Style.as_inline_code longident) lid | Incoherent_label_order -> Location.errorf ~loc "This function is applied to arguments@ \ @@ -6018,45 +7011,42 @@ let report_error ~loc env = function | Not_a_packed_module ty -> Location.errorf ~loc "This expression is packed module, but the expected type is@ %a" - Printtyp.type_expr ty - | Unexpected_existential (reason, name, types) -> + (Style.as_inline_code Printtyp.type_expr) ty + | Unexpected_existential (reason, name) -> let reason_str = - match reason with + match reason with | In_class_args -> - "Existential types are not allowed in class arguments" + dprintf "Existential types are not allowed in class arguments" | In_class_def -> - "Existential types are not allowed in bindings inside \ + dprintf "Existential types are not allowed in bindings inside \ class definition" | In_self_pattern -> - "Existential types are not allowed in self patterns" + dprintf "Existential types are not allowed in self patterns" | At_toplevel -> - "Existential types are not allowed in toplevel bindings" + dprintf "Existential types are not allowed in toplevel bindings" | In_group -> - "Existential types are not allowed in \"let ... and ...\" bindings" + dprintf "Existential types are not allowed in %a bindings" + Style.inline_code "let ... and ..." | In_rec -> - "Existential types are not allowed in recursive bindings" + dprintf "Existential types are not allowed in recursive bindings" | With_attributes -> - "Existential types are not allowed in presence of attributes" + dprintf + "Existential types are not allowed in presence of attributes" in - begin match List.find (fun ty -> ty <> "$" ^ name) types with - | example -> - Location.errorf ~loc - "%s,@ but this pattern introduces the existential type %s." - reason_str example - | exception Not_found -> - Location.errorf ~loc - "%s,@ but the constructor %s introduces existential types." - reason_str name - end + Location.errorf ~loc + "%t,@ but the constructor %a introduces existential types." + reason_str Style.inline_code name | Invalid_interval -> Location.errorf ~loc "@[Only character intervals are supported in patterns.@]" | Invalid_for_loop_index -> Location.errorf ~loc - "@[Invalid for-loop index: only variables and _ are allowed.@]" + "@[Invalid for-loop index: only variables and %a are allowed.@]" + Style.inline_code "_" | No_value_clauses -> Location.errorf ~loc - "None of the patterns in this 'match' expression match values." + "None of the patterns in this %a expression match values." + Style.inline_code "match" | Exception_pattern_disallowed -> Location.errorf ~loc "@[Exception patterns are not allowed in this position.@]" @@ -6073,41 +7063,47 @@ let report_error ~loc env = function "@[This constructor expects an inlined record argument.@]" | Unrefuted_pattern pat -> Location.errorf ~loc - "@[%s@ %s@ %a@]" + "@[%s@ %s@ @[%a@]@]" "This match case could not be refuted." "Here is an example of a value that would reach it:" - Printpat.top_pretty pat + (Style.as_inline_code Printpat.pretty_val) pat | Invalid_extension_constructor_payload -> Location.errorf ~loc - "Invalid [%%extension_constructor] payload, a constructor is expected." + "Invalid %a payload, a constructor is expected." + Style.inline_code "[%extension_constructor]" | Not_an_extension_constructor -> Location.errorf ~loc "This constructor is not an extension constructor." | Literal_overflow ty -> Location.errorf ~loc - "Integer literal exceeds the range of representable integers of type %s" - ty + "Integer literal exceeds the range of representable integers of type %a" + Style.inline_code ty | Unknown_literal (n, m) -> - Location.errorf ~loc "Unknown modifier '%c' for literal %s%c" m n m + let pp_lit ppf (n,m) = fprintf ppf "%s%c" n m in + Location.errorf ~loc "Unknown modifier %a for literal %a" + (Style.as_inline_code pp_print_char) m + (Style.as_inline_code pp_lit) (n,m) | Illegal_letrec_pat -> Location.errorf ~loc - "Only variables are allowed as left-hand side of `let rec'" + "Only variables are allowed as left-hand side of %a" + Style.inline_code "let rec" | Illegal_letrec_expr -> Location.errorf ~loc - "This kind of expression is not allowed as right-hand side of `let rec'" + "This kind of expression is not allowed as right-hand side of %a" + Style.inline_code "let rec" | Illegal_class_expr -> Location.errorf ~loc "This kind of recursive class expression is not allowed" | Letop_type_clash(name, err) -> report_unification_error ~loc env err (function ppf -> - fprintf ppf "The operator %s has type" name) + fprintf ppf "The operator %a has type" Style.inline_code name) (function ppf -> fprintf ppf "but it was expected to have type") | Andop_type_clash(name, err) -> report_unification_error ~loc env err (function ppf -> - fprintf ppf "The operator %s has type" name) + fprintf ppf "The operator %a has type" Style.inline_code name) (function ppf -> fprintf ppf "but it was expected to have type") | Bindings_type_clash(err) -> @@ -6117,11 +7113,16 @@ let report_error ~loc env = function (function ppf -> fprintf ppf "but bindings were expected of type") | Unbound_existential (ids, ty) -> + let pp_ident ppf id = pp_print_string ppf (Ident.name id) in + let pp_type ppf (ids,ty)= + fprintf ppf "@[type %a.@ %a@]@]" + (pp_print_list ~pp_sep:pp_print_space pp_ident) ids + Printtyp.type_expr ty + in Location.errorf ~loc - "@[<2>%s:@ @[type %s.@ %a@]@]" + "@[<2>%s:@ %a@]" "This type does not bind all existentials in the constructor" - (String.concat " " (List.map Ident.name ids)) - Printtyp.type_expr ty + (Style.as_inline_code pp_type) (ids, ty) | Missing_type_constraint -> Location.errorf ~loc "@[%s@ %s@]" @@ -6144,13 +7145,13 @@ let report_error ~loc env = function Location.errorf ~loc "This %s should not be a %s,@ \ the expected type is@ %a%t" - ctx sort Printtyp.type_expr ty + ctx sort (Style.as_inline_code Printtyp.type_expr) ty (report_type_expected_explanation_opt explanation) | Expr_not_a_record_type ty -> Location.errorf ~loc "This expression has type %a@ \ which is not a record type." - Printtyp.type_expr ty + (Style.as_inline_code Printtyp.type_expr) ty let report_error ~loc env err = Printtyp.wrap_printing_env ~error:true env @@ -6172,12 +7173,16 @@ let () = Env.add_delayed_check_forward := add_delayed_check; () +(* drop the need to call [Parmatch.typed_case] from the external API *) +let check_partial ?lev a b c cases = + check_partial ?lev a b c (List.map Parmatch.typed_case cases) + (* drop ?recarg argument from the external API *) -let type_expect ?in_function env e ty = type_expect ?in_function env e ty +let type_expect env e ty = type_expect env e ty let type_exp env e = type_exp env e let type_argument env e t1 t2 = type_argument env e t1 t2 (* Merlin specific *) -let partial_pred = +let partial_pred ~lev = let splitting_mode = Refine_or {inside_nonsplit_or = false} in - partial_pred ~splitting_mode + partial_pred ~splitting_mode ~lev diff --git a/src/ocaml/typing/typecore.mli b/src/ocaml/typing/typecore.mli index 73772b47ac..ae47ac4a89 100644 --- a/src/ocaml/typing/typecore.mli +++ b/src/ocaml/typing/typecore.mli @@ -56,6 +56,7 @@ type pattern_variable = pv_loc: Location.t; pv_as_var: bool; pv_attributes: Typedtree.attributes; + pv_uid : Uid.t; } val mk_expected: @@ -120,7 +121,6 @@ val check_partial: ?lev:int -> Env.t -> type_expr -> Location.t -> Typedtree.value Typedtree.case list -> Typedtree.partial val type_expect: - ?in_function:(Location.t * type_expr) -> Env.t -> Parsetree.expression -> type_expected -> Typedtree.expression val type_exp: Env.t -> Parsetree.expression -> Typedtree.expression @@ -134,6 +134,7 @@ val option_some: Env.t -> Typedtree.expression -> Typedtree.expression val option_none: Env.t -> type_expr -> Location.t -> Typedtree.expression val extract_option_type: Env.t -> type_expr -> type_expr val generalizable: int -> type_expr -> bool +val generalize_structure_exp: Typedtree.expression -> unit type delayed_check val delayed_checks: delayed_check list ref val reset_delayed_checks: unit -> unit @@ -148,15 +149,26 @@ type error = | Constructor_arity_mismatch of Longident.t * int * int | Label_mismatch of Longident.t * Errortrace.unification_error | Pattern_type_clash : - Errortrace.unification_error * _ Typedtree.pattern_desc option + Errortrace.unification_error * Parsetree.pattern_desc option -> error | Or_pattern_type_clash of Ident.t * Errortrace.unification_error | Multiply_bound_variable of string | Orpat_vars of Ident.t * Ident.t list | Expr_type_clash of Errortrace.unification_error * type_forcing_context option - * Typedtree.expression_desc option - | Apply_non_function of type_expr + * Parsetree.expression_desc option + | Function_arity_type_clash of + { syntactic_arity : int; + type_constraint : type_expr; + trace : Errortrace.unification_error; + } + | Apply_non_function of { + funct : Typedtree.expression; + func_ty : type_expr; + res_ty : type_expr; + previous_arg_loc : Location.t; + extra_arg_loc : Location.t; + } | Apply_wrong_label of arg_label * type_expr * bool | Label_multiply_defined of string | Label_missing of Ident.t list @@ -194,7 +206,7 @@ type error = | Modules_not_allowed | Cannot_infer_signature | Not_a_packed_module of type_expr - | Unexpected_existential of existential_restriction * string * string list + | Unexpected_existential of existential_restriction * string | Invalid_interval | Invalid_for_loop_index | No_value_clauses @@ -247,7 +259,8 @@ val type_package: val constant: Parsetree.constant -> (Asttypes.constant, error) result -val check_recursive_bindings : Env.t -> Typedtree.value_binding list -> unit +val annotate_recursive_bindings : + Env.t -> Typedtree.value_binding list -> Typedtree.value_binding list val check_recursive_class_bindings : Env.t -> Ident.t list -> Typedtree.class_expr list -> unit @@ -257,7 +270,5 @@ val partial_pred : ?explode:int -> Env.t -> type_expr -> - (label, constructor_description) Hashtbl.t -> - (label, label_description) Hashtbl.t -> - Parsetree.pattern -> - Typedtree.value Typedtree.pattern_desc Typedtree.pattern_data option + Typedtree.pattern -> + Typedtree.pattern option diff --git a/src/ocaml/typing/typedecl.ml b/src/ocaml/typing/typedecl.ml index 502418335f..626cd35fb5 100644 --- a/src/ocaml/typing/typedecl.ml +++ b/src/ocaml/typing/typedecl.ml @@ -26,13 +26,22 @@ module String = Misc.String type native_repr_kind = Unboxed | Untagged +(* Our static analyses explore the set of type expressions "reachable" + from a type declaration, by expansion of definitions or by the + subterm relation (a type expression is syntactically contained + in another). *) +type reaching_type_path = reaching_type_step list +and reaching_type_step = + | Expands_to of type_expr * type_expr + | Contains of type_expr * type_expr + type error = Repeated_parameter | Duplicate_constructor of string | Too_many_constructors | Duplicate_label of string - | Recursive_abbrev of string - | Cycle_in_def of string * type_expr + | Recursive_abbrev of string * Env.t * reaching_type_path + | Cycle_in_def of string * Env.t * reaching_type_path | Definition_mismatch of type_expr * Env.t * Includecore.type_mismatch option | Constraint_failed of Env.t * Errortrace.unification_error | Inconsistent_constraint of Env.t * Errortrace.unification_error @@ -41,7 +50,7 @@ type error = definition: Path.t; used_as: type_expr; defined_as: type_expr; - expansions: (type_expr * type_expr) list; + reaching_path: reaching_type_path; } | Null_arity_external | Missing_native_external @@ -82,14 +91,19 @@ let get_unboxed_from_attributes sdecl = (* Enter all declared types in the environment as abstract types *) -let add_type ~long_path ~check id decl env = +let add_type ~long_path ~check ?shape id decl env = Builtin_attributes.warning_scope ~ppwarning:false decl.type_attributes (fun () -> match long_path with - | true -> Env.add_type_long_path ~check id decl env - | false -> Env.add_type ~check id decl env) - -let enter_type rec_flag env sdecl (id, uid) = + | true -> Env.add_type_long_path ~check ?shape id decl env + | false -> Env.add_type ~check ?shape id decl env) + +(* Add a dummy type declaration to the environment, with the given arity. + The [type_kind] is [Type_abstract], but there is a generic [type_manifest] + for abbreviations, to allow polymorphic expansion, except if + [abstract_abbrevs] is given along with a reason for not allowing expansion. + This function is only used in [transl_type_decl]. *) +let enter_type ?abstract_abbrevs rec_flag env sdecl (id, uid) = let needed = match rec_flag with | Asttypes.Nonrecursive -> @@ -105,15 +119,19 @@ let enter_type rec_flag env sdecl (id, uid) = in let arity = List.length sdecl.ptype_params in if not needed then env else + let abstract_source, type_manifest = + match sdecl.ptype_manifest, abstract_abbrevs with + | None, _ -> Definition, None + | Some _, None -> Definition, Some (Btype.newgenvar ()) + | Some _, Some reason -> reason, None + in let decl = { type_params = List.map (fun _ -> Btype.newgenvar ()) sdecl.ptype_params; type_arity = arity; - type_kind = Type_abstract; + type_kind = Type_abstract abstract_source; type_private = sdecl.ptype_private; - type_manifest = - begin match sdecl.ptype_manifest with None -> None - | Some _ -> Some(Ctype.newvar ()) end; + type_manifest = type_manifest; type_variance = Variance.unknown_signature ~injective:false ~arity; type_separability = Types.Separability.default_signature ~arity; type_is_newtype = false; @@ -127,16 +145,6 @@ let enter_type rec_flag env sdecl (id, uid) = in add_type ~long_path:true ~check:true id decl env -let update_type temp_env env id loc = - let path = Path.Pident id in - let decl = Env.find_type path temp_env in - match decl.type_manifest with None -> () - | Some ty -> - let params = List.map (fun _ -> Ctype.newvar ()) decl.type_params in - try Ctype.unify env (Ctype.newconstr path params) ty - with Ctype.Unify err -> - raise (Error(loc, Type_clash (env, err))) - (* Determine if a type's values are represented by floats at run-time. *) let is_float env ty = match Typedecl_unboxed.get_unboxed_type_representation env ty with @@ -223,9 +231,11 @@ let transl_labels env univars closed lbls = Builtin_attributes.warning_scope attrs (fun () -> let arg = Ast_helper.Typ.force_poly arg in - let cty = transl_simple_type env ?univars closed arg in + let cty = transl_simple_type env ?univars ~closed arg in {ld_id = Ident.create_local name.txt; - ld_name = name; ld_mutable = mut; + ld_name = name; + ld_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); + ld_mutable = mut; ld_type = cty; ld_loc = loc; ld_attributes = attrs} ) in @@ -235,14 +245,12 @@ let transl_labels env univars closed lbls = (fun ld -> let ty = ld.ld_type.ctyp_type in let ty = match get_desc ty with Tpoly(t,[]) -> t | _ -> ty in - let ld_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) in - Env.register_uid ld_uid ld.ld_loc; {Types.ld_id = ld.ld_id; ld_mutable = ld.ld_mutable; ld_type = ty; ld_loc = ld.ld_loc; ld_attributes = ld.ld_attributes; - ld_uid; + ld_uid = ld.ld_uid; } ) lbls in @@ -250,7 +258,7 @@ let transl_labels env univars closed lbls = let transl_constructor_arguments env univars closed = function | Pcstr_tuple l -> - let l = List.map (transl_simple_type env ?univars closed) l in + let l = List.map (transl_simple_type env ?univars ~closed) l in Types.Cstr_tuple (List.map (fun t -> t.ctyp_type) l), Cstr_tuple l | Pcstr_record l -> @@ -268,60 +276,82 @@ let make_constructor env loc type_path type_params svars sargs sret_type = | Some sret_type -> (* if it's a generalized constructor we must first narrow and then widen so as to not introduce any new constraints *) - let z = narrow () in - reset_type_variables (); - let univars, closed = - match svars with - | [] -> None, false - | vs -> - Ctype.begin_def(); - Some (make_poly_univars (List.map (fun v -> v.txt) vs)), true - in - let args, targs = - transl_constructor_arguments env univars closed sargs - in - let tret_type = transl_simple_type env ?univars closed sret_type in - let ret_type = tret_type.ctyp_type in - (* TODO add back type_path as a parameter ? *) - begin match get_desc ret_type with - | Tconstr (p', _, _) when Path.same type_path p' -> () - | _ -> - let trace = - (* Expansion is not helpful here -- the restriction on GADT return - types is purely syntactic. (In the worst case, expansion - produces gibberish.) *) - [Ctype.unexpanded_diff - ~got:ret_type - ~expected:(Ctype.newconstr type_path type_params)] + (* narrow and widen are now invoked through wrap_type_variable_scope *) + TyVarEnv.with_local_scope begin fun () -> + let closed = svars <> [] in + let targs, tret_type, args, ret_type, _univars = + Ctype.with_local_level_if closed begin fun () -> + TyVarEnv.reset (); + let univar_list = + TyVarEnv.make_poly_univars (List.map (fun v -> v.txt) svars) in + let univars = if closed then Some univar_list else None in + let args, targs = + transl_constructor_arguments env univars closed sargs in - raise (Error(sret_type.ptyp_loc, - Constraint_failed(env, - Errortrace.unification_error ~trace))) - end; - begin match univars with - | None -> () - | Some univars -> - Ctype.end_def(); - Btype.iter_type_expr_cstr_args Ctype.generalize args; - Ctype.generalize ret_type; - let _vars = instance_poly_univars env loc univars in - let set_level t = Ctype.unify_var env (Ctype.newvar()) t in - Btype.iter_type_expr_cstr_args set_level args; - set_level ret_type; - end; - widen z; + let tret_type = + transl_simple_type env ?univars ~closed sret_type in + let ret_type = tret_type.ctyp_type in + (* TODO add back type_path as a parameter ? *) + begin match get_desc ret_type with + | Tconstr (p', _, _) when Path.same type_path p' -> () + | _ -> + let trace = + (* Expansion is not helpful here -- the restriction on GADT + return types is purely syntactic. (In the worst case, + expansion produces gibberish.) *) + [Ctype.unexpanded_diff + ~got:ret_type + ~expected:(Ctype.newconstr type_path type_params)] + in + raise (Error(sret_type.ptyp_loc, + Constraint_failed( + env, Errortrace.unification_error ~trace))) + end; + (targs, tret_type, args, ret_type, univar_list) + end + ~post: begin fun (_, _, args, ret_type, univars) -> + Btype.iter_type_expr_cstr_args Ctype.generalize args; + Ctype.generalize ret_type; + let _vars = TyVarEnv.instance_poly_univars env loc univars in + let set_level t = Ctype.enforce_current_level env t in + Btype.iter_type_expr_cstr_args set_level args; + set_level ret_type; + end + in targs, Some tret_type, args, Some ret_type + end + + +let shape_map_labels = + List.fold_left (fun map { ld_id; ld_uid; _} -> + Shape.Map.add_label map ld_id ld_uid) + Shape.Map.empty + +let shape_map_cstrs = + List.fold_left (fun map { cd_id; cd_uid; cd_args; _ } -> + let cstr_shape_map = + let label_decls = + match cd_args with + | Cstr_tuple _ -> [] + | Cstr_record ldecls -> ldecls + in + shape_map_labels label_decls + in + Shape.Map.add_constr map cd_id + @@ Shape.str ~uid:cd_uid cstr_shape_map) + (Shape.Map.empty) + let transl_declaration env sdecl (id, uid) = (* Bind type parameters *) - reset_type_variables(); - Ctype.begin_def (); + Ctype.with_local_level begin fun () -> + TyVarEnv.reset(); let tparams = make_params env sdecl.ptype_params in let params = List.map (fun (cty, _) -> cty.ctyp_type) tparams in let cstrs = List.map (fun (sty, sty', loc) -> - transl_simple_type env false sty, - transl_simple_type env false sty', loc) + transl_simple_type env ~closed:false sty, + transl_simple_type env ~closed:false sty', loc) sdecl.ptype_cstrs in let unboxed_attr = get_unboxed_from_attributes sdecl in @@ -370,7 +400,7 @@ let transl_declaration env sdecl (id, uid) = in let (tkind, kind) = match sdecl.ptype_kind with - | Ptype_abstract -> Ttype_abstract, Type_abstract + | Ptype_abstract -> Ttype_abstract, Type_abstract Definition | Ptype_variant scstrs -> if List.exists (fun cstr -> cstr.pcd_res <> None) scstrs then begin match cstrs with @@ -398,6 +428,7 @@ let transl_declaration env sdecl (id, uid) = let tcstr = { cd_id = name; cd_name = scstr.pcd_name; + cd_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); cd_vars = scstr.pcd_vars; cd_args = targs; cd_res = tret_type; @@ -405,14 +436,12 @@ let transl_declaration env sdecl (id, uid) = cd_attributes = scstr.pcd_attributes } in let cstr = - let cd_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) in - Env.register_uid cd_uid scstr.pcd_loc; { Types.cd_id = name; cd_args = args; cd_res = ret_type; cd_loc = scstr.pcd_loc; cd_attributes = scstr.pcd_attributes; - cd_uid; } + cd_uid = tcstr.cd_uid; } in tcstr, cstr in @@ -438,7 +467,7 @@ let transl_declaration env sdecl (id, uid) = None -> None, None | Some sty -> let no_row = not (is_fixed_type sdecl) in - let cty = transl_simple_type env no_row sty in + let cty = transl_simple_type env ~closed:no_row sty in Some cty, Some cty.ctyp_type in let arity = List.length params in @@ -467,7 +496,6 @@ let transl_declaration env sdecl (id, uid) = try Ctype.unify env ty ty' with Ctype.Unify err -> raise(Error(loc, Inconsistent_constraint (env, err)))) cstrs; - Ctype.end_def (); (* Add abstract row *) if is_fixed_type sdecl then begin let p, _ = @@ -477,18 +505,29 @@ let transl_declaration env sdecl (id, uid) = in set_private_row env sdecl.ptype_loc p decl end; - { - typ_id = id; - typ_name = sdecl.ptype_name; - typ_params = tparams; - typ_type = decl; - typ_cstrs = cstrs; - typ_loc = sdecl.ptype_loc; - typ_manifest = tman; - typ_kind = tkind; - typ_private = sdecl.ptype_private; - typ_attributes = sdecl.ptype_attributes; - } + let decl = + { + typ_id = id; + typ_name = sdecl.ptype_name; + typ_params = tparams; + typ_type = decl; + typ_cstrs = cstrs; + typ_loc = sdecl.ptype_loc; + typ_manifest = tman; + typ_kind = tkind; + typ_private = sdecl.ptype_private; + typ_attributes = sdecl.ptype_attributes; + } + in + let typ_shape = + let uid = decl.typ_type.type_uid in + match decl.typ_kind with + | Ttype_variant cstrs -> Shape.str ~uid (shape_map_cstrs cstrs) + | Ttype_record labels -> Shape.str ~uid (shape_map_labels labels) + | Ttype_abstract | Ttype_open -> Shape.leaf uid + in + decl, typ_shape + end (* Generalize a type declaration *) @@ -526,7 +565,7 @@ let rec check_constraints_rec env loc visited ty = end; List.iter (check_constraints_rec env loc visited) args | Tpoly (ty, tl) -> - let _, ty = Ctype.instance_poly false tl ty in + let _, ty = Ctype.instance_poly ~fixed:false tl ty in check_constraints_rec env loc visited ty | _ -> Btype.iter_type_expr (check_constraints_rec env loc visited) ty @@ -550,7 +589,7 @@ let check_constraints env sdecl (_, decl) = (fun (sty, _) ty -> check_constraints_rec env sty.ptyp_loc visited ty) sdecl.ptype_params decl.type_params; begin match decl.type_kind with - | Type_abstract -> () + | Type_abstract _ -> () | Type_variant (l, _rep) -> let find_pl = function Ptype_variant pl -> pl @@ -644,80 +683,260 @@ let check_coherence env loc dpath decl = let check_abbrev env sdecl (id, decl) = check_coherence env sdecl.ptype_loc (Path.Pident id) decl -(* Check that recursion is well-founded *) -let check_well_founded env loc path to_check ty = - let visited = ref TypeMap.empty in - let rec check ty0 parents ty = +(* Note: Well-foundedness for OCaml types + + We want to guarantee that all cycles within OCaml types are + "guarded". + + More precisely, we consider a reachability relation + "[t] is reachable [guarded|unguarded] from [u]" + defined as follows: + + - [t1, t2...] are reachable guarded from object types + [< m1 : t1; m2 : t2; ... >] + or polymorphic variants + [[`A of t1 | `B of t2 | ...]]. + + - [t1, t2...] are reachable rectypes-guarded from + [t1 -> t2], [t1 * t2 * ...], and all other built-in + contractive type constructors. + + (By rectypes-guarded we mean: guarded if -rectypes is set, + unguarded if it is not set.) + + - If [(t1, t2...) c] is a datatype (variant or record), + then [t1, t2...] are reachable rectypes-guarded from it. + + - If [(t1, t2...) c] is an abstract type, + then [t1, t2...] are reachable unguarded from it. + + - If [(t1, t2...) c] is an (expandable) abbreviation, + then its expansion is reachable unguarded from it. + Note that we do not define [t1, t2...] as reachable. + + - The relation is transitive and guardedness of a composition + is the disjunction of each guardedness: + if t1 is reachable from t2 and t2 is reachable from t3; + then t1 is reachable guarded from t3 if t1 is guarded in t2 + or t2 is guarded in t3, and reachable unguarded otherwise. + + A type [t] is not well-founded if and only if [t] is reachable + unguarded in [t]. + + Notice that, in the case of datatypes, the arguments of + a parametrized datatype are reachable (they must not contain + recursive occurrences of the type), but the definition of the + datatype is not defined as reachable. + + (* well-founded *) + type t = Foo of u + and u = t + + (* ill-founded *) + type 'a t = Foo of 'a + and u = u t + > Error: The type abbreviation u is cyclic + + Indeed, in the second example [u] is reachable unguarded in [u t] + -- its own definition. +*) + +(* Note: Forms of ill-foundedness + + Several OCaml language constructs could introduce ill-founded + types, and there are several distinct checks that forbid different + sources of ill-foundedness. + + 1. Type aliases. + + (* well-founded *) + type t = < x : 'a > as 'a + + (* ill-founded, unless -rectypes is used *) + type t = (int * 'a) as 'a + > Error: This alias is bound to type int * 'a + > but is used as an instance of type 'a + > The type variable 'a occurs inside int * 'a + + Ill-foundedness coming from type aliases is detected by the "occur check" + used by our type unification algorithm. See typetexp.ml. + + 2. Type abbreviations. + + (* well-founded *) + type t = < x : t > + + (* ill-founded, unless -rectypes is used *) + type t = (int * t) + > Error: The type abbreviation t is cyclic + + Ill-foundedness coming from type abbreviations is detected by + [check_well_founded] below. + + 3. Recursive modules. + + (* well-founded *) + module rec M : sig type t = < x : M.t > end = M + + (* ill-founded, unless -rectypes is used *) + module rec M : sig type t = int * M.t end = M + > Error: The definition of M.t contains a cycle: + > int * M.t + + This is also checked by [check_well_founded] below, + as called from [check_recmod_typedecl]. + + 4. Functor application + + A special case of (3) is that a type can be abstract + in a functor definition, and be instantiated with + an abbreviation in an application of the functor. + This can introduce ill-foundedness, so functor applications + must be checked by re-checking the type declarations of their result. + + module type T = sig type t end + module Fix(F:(T -> T)) = struct + (* this recursive definition is well-founded + as F(Fixed).t contains no reachable type expression. *) + module rec Fixed : T with type t = F(Fixed).t = F(Fixed) + end + + (* well-founded *) + Module M = Fix(functor (M:T) -> struct type t = < x : M.t > end) + + (* ill-founded *) + module M = Fix(functor (M:T) -> struct type t = int * M.t end);; + > Error: In the signature of this functor application: + > The definition of Fixed.t contains a cycle: + > F(Fixed).t +*) + +(* Check that a type expression is well-founded: + - if -rectypes is used, we must prevent non-contractive fixpoints + ('a as 'a) + - if -rectypes is not used, we only allow cycles in the type graph + if they go through an object or polymorphic variant type *) + +let check_well_founded ~abs_env env loc path to_check visited ty0 = + let rec check parents trace ty = if TypeSet.mem ty parents then begin (*Format.eprintf "@[%a@]@." Printtyp.raw_type_expr ty;*) - if match get_desc ty0 with - | Tconstr (p, _, _) -> Path.same p path - | _ -> false - then raise (Error (loc, Recursive_abbrev (Path.name path))) - else raise (Error (loc, Cycle_in_def (Path.name path, ty0))) + let err = + let reaching_path, rec_abbrev = + (* The reaching trace is accumulated in reverse order, we + reverse it to get a reaching path. *) + match trace with + | [] -> assert false + | Expands_to (ty1, _) :: trace when (match get_desc ty1 with + Tconstr (p,_,_) -> Path.same p path | _ -> false) -> + List.rev trace, true + | trace -> List.rev trace, false + in + if rec_abbrev + then Recursive_abbrev (Path.name path, abs_env, reaching_path) + else Cycle_in_def (Path.name path, abs_env, reaching_path) + in raise (Error (loc, err)) end; let (fini, parents) = try + (* Map each node to the set of its already checked parents *) let prev = TypeMap.find ty !visited in if TypeSet.subset parents prev then (true, parents) else - (false, TypeSet.union parents prev) + let parents = TypeSet.union parents prev in + visited := TypeMap.add ty parents !visited; + (false, parents) with Not_found -> + visited := TypeMap.add ty parents !visited; (false, parents) in if fini then () else let rec_ok = match get_desc ty with - Tconstr(p,_,_) -> + | Tconstr(p,_,_) -> !Clflags.recursive_types && Ctype.is_contractive env p | Tobject _ | Tvariant _ -> true | _ -> !Clflags.recursive_types in - let visited' = TypeMap.add ty parents !visited in - let arg_exn = - try - visited := visited'; - let parents = - if rec_ok then TypeSet.empty else TypeSet.add ty parents in - Btype.iter_type_expr (check ty0 parents) ty; - None - with e -> - visited := visited'; Some e - in + if rec_ok then () else + let parents = TypeSet.add ty parents in match get_desc ty with - | Tconstr(p, _, _) when arg_exn <> None || to_check p -> - if to_check p then Option.iter raise arg_exn - else Btype.iter_type_expr (check ty0 TypeSet.empty) ty; - begin try - let ty' = Ctype.try_expand_once_opt env ty in - let ty0 = if TypeSet.is_empty parents then ty else ty0 in - check ty0 (TypeSet.add ty parents) ty' - with - Ctype.Cannot_expand -> Option.iter raise arg_exn + | Tconstr(p, tyl, _) -> + let to_check = to_check p in + if to_check then List.iter (check_subtype parents trace ty) tyl; + begin match Ctype.try_expand_once_opt env ty with + | ty' -> check parents (Expands_to (ty, ty') :: trace) ty' + | exception Ctype.Cannot_expand -> + if not to_check then List.iter (check_subtype parents trace ty) tyl end - | _ -> Option.iter raise arg_exn + | _ -> + Btype.iter_type_expr (check_subtype parents trace ty) ty + and check_subtype parents trace outer_ty inner_ty = + check parents (Contains (outer_ty, inner_ty) :: trace) inner_ty in let snap = Btype.snapshot () in - try Ctype.wrap_trace_gadt_instances env (check ty TypeSet.empty) ty + try Ctype.wrap_trace_gadt_instances env (check TypeSet.empty []) ty0 with Ctype.Escape _ -> - (* Will be detected by check_recursion *) + (* Will be detected by check_regularity *) Btype.backtrack snap -let check_well_founded_manifest env loc path decl = +let check_well_founded_manifest ~abs_env env loc path decl = if decl.type_manifest = None then () else let args = List.map (fun _ -> Ctype.newvar()) decl.type_params in - check_well_founded env loc path (Path.same path) (Ctype.newconstr path args) - -let check_well_founded_decl env loc path decl to_check = + let visited = ref TypeMap.empty in + check_well_founded ~abs_env env loc path (Path.same path) visited + (Ctype.newconstr path args) + +(* Given a new type declaration [type t = ...] (potentially mutually-recursive), + we check that accepting the declaration does not introduce ill-founded types. + + Note: we check that the types at the toplevel of the declaration + are not reachable unguarded from themselves, that is, we check that + there is no cycle going through the "root" of the declaration. But + we *also* check that all the type sub-expressions reachable from + the root even those that are guarded, are themselves + well-founded. (So we check the absence of cycles, even for cycles + going through inner type subexpressions but not the root. + + We are not actually sure that this "deep check" is necessary + (we don't have an example at hand where it is necessary), but we + are doing it anyway out of caution. +*) +let check_well_founded_decl ~abs_env env loc path decl to_check = let open Btype in + (* We iterate on all subexpressions of the declaration to check + "in depth" that no ill-founded type exists. *) let it = - {type_iterators with - it_type_expr = (fun _ -> check_well_founded env loc path to_check)} in + let checked = + (* [checked] remembers the types that the iterator already + checked, to avoid looping on cyclic types. *) + ref TypeSet.empty in + let visited = + (* [visited] remembers the inner visits performed by + [check_well_founded] on each type expression reachable from + this declaration. This avoids unnecessary duplication of + [check_well_founded] work when invoked on two parts of the + type declaration that have common subexpressions. *) + ref TypeMap.empty in + {type_iterators with it_type_expr = + (fun self ty -> + if TypeSet.mem ty !checked then () else begin + check_well_founded ~abs_env env loc path to_check visited ty; + checked := TypeSet.add ty !checked; + self.it_do_type_expr self ty + end)} in it.it_type_declaration it (Ctype.generic_instance_declaration decl) -(* Check for ill-defined abbrevs *) +(* Check for non-regular abbreviations; an abbreviation + [type 'a t = ...] is non-regular if the expansion of [...] + contains instances [ty t] where [ty] is not equal to ['a]. + + Note: in the case of a constrained type definition + [type 'a t = ... constraint 'a = ...], we require + that all instances in [...] be equal to the constrained type. +*) -let check_recursion ~orig_env env loc path decl to_check = +let check_regularity ~abs_env env loc path decl to_check = (* to_check is true for potentially mutually recursive paths. (path, decl) is the type declaration to be checked. *) @@ -725,19 +944,19 @@ let check_recursion ~orig_env env loc path decl to_check = let visited = ref TypeSet.empty in - let rec check_regular cpath args prev_exp prev_expansions ty = + let rec check_regular cpath args prev_exp trace ty = if not (TypeSet.mem ty !visited) then begin visited := TypeSet.add ty !visited; match get_desc ty with | Tconstr(path', args', _) -> if Path.same path path' then begin - if not (Ctype.is_equal orig_env false args args') then + if not (Ctype.is_equal abs_env false args args') then raise (Error(loc, Non_regular { definition=path; used_as=ty; defined_as=Ctype.newconstr path args; - expansions=List.rev prev_expansions; + reaching_path=List.rev trace; })) end (* Attempt to expand a type abbreviation if: @@ -753,23 +972,28 @@ let check_recursion ~orig_env env loc path decl to_check = let (params, body) = Ctype.instance_parameterized_type params0 body0 in begin - try List.iter2 (Ctype.unify orig_env) params args' + try List.iter2 (Ctype.unify abs_env) args' params with Ctype.Unify err -> - raise (Error(loc, Constraint_failed (orig_env, err))); + raise (Error(loc, Constraint_failed (abs_env, err))); end; check_regular path' args - (path' :: prev_exp) ((ty,body) :: prev_expansions) + (path' :: prev_exp) (Expands_to (ty,body) :: trace) body with Not_found -> () end; - List.iter (check_regular cpath args prev_exp prev_expansions) args' + List.iter (check_subtype cpath args prev_exp trace ty) args' | Tpoly (ty, tl) -> - let (_, ty) = Ctype.instance_poly ~keep_names:true false tl ty in - check_regular cpath args prev_exp prev_expansions ty + let (_, ty) = + Ctype.instance_poly ~keep_names:true ~fixed:false tl ty in + check_regular cpath args prev_exp trace ty | _ -> Btype.iter_type_expr - (check_regular cpath args prev_exp prev_expansions) ty - end in + (check_subtype cpath args prev_exp trace ty) ty + end + and check_subtype cpath args prev_exp trace outer_ty inner_ty = + let trace = Contains (outer_ty, inner_ty) :: trace in + check_regular cpath args prev_exp trace inner_ty + in Option.iter (fun body -> @@ -780,10 +1004,10 @@ let check_recursion ~orig_env env loc path decl to_check = check_regular path args [] [] body) decl.type_manifest -let check_abbrev_recursion ~orig_env env id_loc_list to_check tdecl = +let check_abbrev_regularity ~abs_env env id_loc_list to_check tdecl = let decl = tdecl.typ_type in let id = tdecl.typ_id in - check_recursion ~orig_env env (List.assoc id id_loc_list) (Path.Pident id) + check_regularity ~abs_env env (List.assoc id id_loc_list) (Path.Pident id) decl to_check let check_duplicates sdecl_list = @@ -819,7 +1043,7 @@ let check_duplicates sdecl_list = (* Force recursion to go through id for private types*) let name_recursion sdecl id decl = match decl with - | { type_kind = Type_abstract; + | { type_kind = Type_abstract _; type_manifest = Some ty; type_private = Private; } when is_fixed_type sdecl -> let ty' = newty2 ~level:(get_level ty) (get_desc ty) in @@ -848,10 +1072,11 @@ let check_redefined_unit (td: Parsetree.type_declaration) = | _ -> () -let add_types_to_env decls env = - List.fold_right - (fun (id, decl) env -> add_type ~long_path:false ~check:true id decl env) - decls env +let add_types_to_env decls shapes env = + List.fold_right2 + (fun (id, decl) shape env -> + add_type ~long_path:false ~check:true ~shape id decl env) + decls shapes env (* Translate a set of type declarations, mutually recursive or not *) let transl_type_decl env rec_flag sdecl_list = @@ -882,79 +1107,89 @@ let transl_type_decl env rec_flag sdecl_list = Uid.mk ~current_unit:(Env.get_unit_name ()) ) sdecl_list in - Ctype.begin_def(); - (* Enter types. *) - let temp_env = - List.fold_left2 (enter_type rec_flag) env sdecl_list ids_list in - (* Translate each declaration. *) - let current_slot = ref None in - let warn_unused = Warnings.is_active (Warnings.Unused_type_declaration "") in - let ids_slots (id, _uid as ids) = - match rec_flag with - | Asttypes.Recursive when warn_unused -> - (* See typecore.ml for a description of the algorithm used - to detect unused declarations in a set of recursive definitions. *) - let slot = ref [] in - let td = Env.find_type (Path.Pident id) temp_env in - Env.set_type_used_callback - td - (fun old_callback -> - match !current_slot with - | Some slot -> slot := td.type_uid :: !slot - | None -> - List.iter Env.mark_type_used (get_ref slot); - old_callback () - ); - ids, Some slot - | Asttypes.Recursive | Asttypes.Nonrecursive -> - ids, None - in - let transl_declaration name_sdecl (id, slot) = - current_slot := slot; - Builtin_attributes.warning_scope - name_sdecl.ptype_attributes - (fun () -> transl_declaration temp_env name_sdecl id) + (* Translate declarations, using a temporary environment where abbreviations + expand to a generic type variable. After that, we check the coherence of + the translated declarations in the resulting new environment. *) + let tdecls, decls, shapes, new_env = + Ctype.with_local_level_iter ~post:generalize_decl begin fun () -> + (* Enter types. *) + let temp_env = + List.fold_left2 (enter_type rec_flag) env sdecl_list ids_list in + (* Translate each declaration. *) + let current_slot = ref None in + let warn_unused = + Warnings.is_active (Warnings.Unused_type_declaration "") in + let ids_slots (id, _uid as ids) = + match rec_flag with + | Asttypes.Recursive when warn_unused -> + (* See typecore.ml for a description of the algorithm used to + detect unused declarations in a set of recursive definitions. *) + let slot = ref [] in + let td = Env.find_type (Path.Pident id) temp_env in + Env.set_type_used_callback + td + (fun old_callback -> + match !current_slot with + | Some slot -> slot := td.type_uid :: !slot + | None -> + List.iter Env.mark_type_used (get_ref slot); + old_callback () + ); + ids, Some slot + | Asttypes.Recursive | Asttypes.Nonrecursive -> + ids, None + in + let transl_declaration name_sdecl (id, slot) = + current_slot := slot; + Builtin_attributes.warning_scope + name_sdecl.ptype_attributes + (fun () -> transl_declaration temp_env name_sdecl id) + in + let tdecls = + List.map2 transl_declaration sdecl_list (List.map ids_slots ids_list) in + let decls, shapes = + List.map (fun (tdecl, shape) -> + (tdecl.typ_id, tdecl.typ_type), shape) tdecls + |> List.split + in + current_slot := None; + (* Check for duplicates *) + check_duplicates sdecl_list; + (* Build the final env. *) + let new_env = add_types_to_env decls shapes env in + ((tdecls, decls, shapes, new_env), List.map snd decls) + end in - let tdecls = - List.map2 transl_declaration sdecl_list (List.map ids_slots ids_list) in - let decls = - List.map (fun tdecl -> (tdecl.typ_id, tdecl.typ_type)) tdecls in - current_slot := None; - (* Check for duplicates *) - check_duplicates sdecl_list; - (* Build the final env. *) - let new_env = add_types_to_env decls env in - (* Update stubs *) - begin match rec_flag with - | Asttypes.Nonrecursive -> () - | Asttypes.Recursive -> - List.iter2 - (fun (id, _) sdecl -> update_type temp_env new_env id sdecl.ptype_loc) - ids_list sdecl_list - end; - (* Generalize type declarations. *) - Ctype.end_def(); - List.iter (fun (_, decl) -> generalize_decl decl) decls; (* Check for ill-formed abbrevs *) let id_loc_list = List.map2 (fun (id, _) sdecl -> (id, sdecl.ptype_loc)) ids_list sdecl_list in + (* [check_abbrev_regularity] and error messages cannot use the new + environment, as this might result in non-termination. Instead we use a + completely abstract version of the temporary environment, giving a reason + for why abbreviations cannot be expanded (#12334, #12368) *) + let abs_env = + List.fold_left2 + (enter_type ~abstract_abbrevs:Rec_check_regularity rec_flag) + env sdecl_list ids_list in List.iter (fun (id, decl) -> - check_well_founded_manifest new_env (List.assoc id id_loc_list) + check_well_founded_manifest ~abs_env new_env (List.assoc id id_loc_list) (Path.Pident id) decl) decls; let to_check = function Path.Pident id -> List.mem_assoc id id_loc_list | _ -> false in List.iter (fun (id, decl) -> - check_well_founded_decl new_env (List.assoc id id_loc_list) (Path.Pident id) + check_well_founded_decl ~abs_env new_env (List.assoc id id_loc_list) + (Path.Pident id) decl to_check) decls; - List.iter - (check_abbrev_recursion ~orig_env:env new_env id_loc_list to_check) tdecls; + List.iter (fun (tdecl, _shape) -> + check_abbrev_regularity ~abs_env new_env id_loc_list to_check tdecl) + tdecls; (* Check that all type variables are closed *) List.iter2 - (fun sdecl tdecl -> + (fun sdecl (tdecl, _shape) -> let decl = tdecl.typ_type in match Ctype.closed_type_decl decl with Some ty -> @@ -981,18 +1216,18 @@ let transl_type_decl env rec_flag sdecl_list = raise (Error (loc, Separability err)) in (* Compute the final environment with variance and immediacy *) - let final_env = add_types_to_env decls env in + let final_env = add_types_to_env decls shapes env in (* Check re-exportation *) List.iter2 (check_abbrev final_env) sdecl_list decls; (* Keep original declaration *) let final_decls = List.map2 - (fun tdecl (_id2, decl) -> + (fun (tdecl, _shape) (_id2, decl) -> { tdecl with typ_type = decl } ) tdecls decls in (* Done *) - (final_decls, final_env) + (final_decls, final_env, shapes) (* Translating type extensions *) @@ -1012,7 +1247,9 @@ let transl_extension_constructor ~scope env type_path type_params if priv = Public then Env.Exported else Env.Exported_private in let cdescr = Env.lookup_constructor ~loc:lid.loc usage lid.txt env in - let (args, cstr_res, _ex) = Ctype.instance_constructor cdescr in + let (args, cstr_res, _ex) = + Ctype.instance_constructor Keep_existentials_flexible cdescr + in let res, ret_type = if cdescr.cstr_generalized then let params = Ctype.instance_list type_params in @@ -1101,12 +1338,22 @@ let transl_extension_constructor ~scope env type_path type_params ext_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); } in + let ext_cstrs = { ext_id = id; ext_name = sext.pext_name; ext_type = ext; ext_kind = kind; Typedtree.ext_loc = sext.pext_loc; Typedtree.ext_attributes = sext.pext_attributes; } + in + let shape = + let map = match ext_cstrs.ext_kind with + | Text_decl (_, Cstr_record lbls, _) -> shape_map_labels lbls + | _ -> Shape.Map.empty + in + Shape.str ~uid:ext_cstrs.ext_type.ext_uid map + in + ext_cstrs, shape let transl_extension_constructor ~scope env type_path type_params typext_params priv sext = @@ -1120,11 +1367,6 @@ let is_rebind ext = | Text_decl _ -> false let transl_type_extension extend env loc styext = - (* Note: it would be incorrect to call [create_scope] *after* - [reset_type_variables] or after [begin_def] (see #10010). *) - let scope = Ctype.create_scope () in - reset_type_variables(); - Ctype.begin_def(); let type_path, type_decl = let lid = styext.ptyext_path in Env.lookup_type ~loc:lid.loc lid.txt env @@ -1169,27 +1411,37 @@ let transl_type_extension extend env loc styext = | None -> () | Some err -> raise (Error(loc, Extension_mismatch (type_path, env, err))) end; - let ttype_params = make_params env styext.ptyext_params in - let type_params = List.map (fun (cty, _) -> cty.ctyp_type) ttype_params in - List.iter2 (Ctype.unify_var env) - (Ctype.instance_list type_decl.type_params) - type_params; - let constructors = - List.map (transl_extension_constructor ~scope env type_path - type_decl.type_params type_params styext.ptyext_private) - styext.ptyext_constructors + let ttype_params, _type_params, constructors = + (* Note: it would be incorrect to call [create_scope] *after* + [TyVarEnv.reset] or after [with_local_level] (see #10010). *) + let scope = Ctype.create_scope () in + Ctype.with_local_level begin fun () -> + TyVarEnv.reset(); + let ttype_params = make_params env styext.ptyext_params in + let type_params = List.map (fun (cty, _) -> cty.ctyp_type) ttype_params in + List.iter2 (Ctype.unify_var env) + (Ctype.instance_list type_decl.type_params) + type_params; + let constructors = + List.map (transl_extension_constructor ~scope env type_path + type_decl.type_params type_params styext.ptyext_private) + styext.ptyext_constructors + in + (ttype_params, type_params, constructors) + end + ~post: begin fun (_, type_params, constructors) -> + (* Generalize types *) + List.iter Ctype.generalize type_params; + List.iter + (fun (ext, _shape) -> + Btype.iter_type_expr_cstr_args Ctype.generalize ext.ext_type.ext_args; + Option.iter Ctype.generalize ext.ext_type.ext_ret_type) + constructors; + end in - Ctype.end_def(); - (* Generalize types *) - List.iter Ctype.generalize type_params; - List.iter - (fun ext -> - Btype.iter_type_expr_cstr_args Ctype.generalize ext.ext_type.ext_args; - Option.iter Ctype.generalize ext.ext_type.ext_ret_type) - constructors; (* Check that all type variables are closed *) List.iter - (fun ext -> + (fun (ext, _shape) -> match Ctype.closed_extension_constructor ext.ext_type with Some ty -> raise(Error(ext.ext_loc, Unbound_type_var_ext(ty, ext.ext_type))) @@ -1197,7 +1449,7 @@ let transl_type_extension extend env loc styext = constructors; (* Check variances are correct *) List.iter - (fun ext-> + (fun (ext, _shape) -> (* Note that [loc] here is distinct from [type_decl.type_loc], which makes the [loc] parameter to this function useful. [loc] is the location of the extension, while [type_decl] points to the original @@ -1210,11 +1462,13 @@ let transl_type_extension extend env loc styext = (* Add extension constructors to the environment *) let newenv = List.fold_left - (fun env ext -> + (fun env (ext, shape) -> let rebind = is_rebind ext in - Env.add_extension ~check:true ~rebind ext.ext_id ext.ext_type env) + Env.add_extension ~check:true ~shape ~rebind + ext.ext_id ext.ext_type env) env constructors in + let constructors, shapes = List.split constructors in let tyext = { tyext_path = type_path; tyext_txt = styext.ptyext_path; @@ -1224,24 +1478,25 @@ let transl_type_extension extend env loc styext = tyext_loc = styext.ptyext_loc; tyext_attributes = styext.ptyext_attributes; } in - (tyext, newenv) + (tyext, newenv, shapes) let transl_type_extension extend env loc styext = Builtin_attributes.warning_scope styext.ptyext_attributes (fun () -> transl_type_extension extend env loc styext) let transl_exception env sext = - let scope = Ctype.create_scope () in - reset_type_variables(); - Ctype.begin_def(); - let ext = - transl_extension_constructor ~scope env - Predef.path_exn [] [] Asttypes.Public sext + let ext, shape = + let scope = Ctype.create_scope () in + Ctype.with_local_level + (fun () -> + TyVarEnv.reset(); + transl_extension_constructor ~scope env + Predef.path_exn [] [] Asttypes.Public sext) + ~post: begin fun (ext, _shape) -> + Btype.iter_type_expr_cstr_args Ctype.generalize ext.ext_type.ext_args; + Option.iter Ctype.generalize ext.ext_type.ext_ret_type; + end in - Ctype.end_def(); - (* Generalize types *) - Btype.iter_type_expr_cstr_args Ctype.generalize ext.ext_type.ext_args; - Option.iter Ctype.generalize ext.ext_type.ext_ret_type; (* Check that all type variables are closed *) begin match Ctype.closed_extension_constructor ext.ext_type with Some ty -> @@ -1250,13 +1505,12 @@ let transl_exception env sext = end; let rebind = is_rebind ext in let newenv = - Env.add_extension ~check:true ~rebind ext.ext_id ext.ext_type env + Env.add_extension ~check:true ~shape ~rebind ext.ext_id ext.ext_type env in - ext, newenv + ext, newenv, shape let transl_type_exception env t = - Builtin_attributes.check_no_alert t.ptyexn_attributes; - let contructor, newenv = + let contructor, newenv, shape = Builtin_attributes.warning_scope t.ptyexn_attributes (fun () -> transl_exception env t.ptyexn_constructor @@ -1264,7 +1518,7 @@ let transl_type_exception env t = in {tyexn_constructor = contructor; tyexn_loc = t.ptyexn_loc; - tyexn_attributes = t.ptyexn_attributes}, newenv + tyexn_attributes = t.ptyexn_attributes}, newenv, shape type native_repr_attribute = @@ -1273,8 +1527,8 @@ type native_repr_attribute = let get_native_repr_attribute attrs ~global_repr = match - Attr_helper.get_no_payload_attribute ["unboxed"; "ocaml.unboxed"] attrs, - Attr_helper.get_no_payload_attribute ["untagged"; "ocaml.untagged"] attrs, + Attr_helper.get_no_payload_attribute "unboxed" attrs, + Attr_helper.get_no_payload_attribute "untagged" attrs, global_repr with | None, None, None -> Native_repr_attr_absent @@ -1287,8 +1541,9 @@ let get_native_repr_attribute attrs ~global_repr = let native_repr_of_type env kind ty = match kind, get_desc (Ctype.expand_head_opt env ty) with - | Untagged, Tconstr (path, _, _) when Path.same path Predef.path_int -> - Some Untagged_int + | Untagged, Tconstr (_, _, _) when + Typeopt.maybe_pointer_type env ty = Lambda.Immediate -> + Some Untagged_immediate | Unboxed, Tconstr (path, _, _) when Path.same path Predef.path_float -> Some Unboxed_float | Unboxed, Tconstr (path, _, _) when Path.same path Predef.path_int32 -> @@ -1450,8 +1705,8 @@ let transl_value_decl env loc valdecl = let transl_with_constraint id ?fixed_row_path ~sig_env ~sig_decl ~outer_env sdecl = Env.mark_type_used sig_decl.type_uid; - reset_type_variables(); - Ctype.begin_def(); + Ctype.with_local_level begin fun () -> + TyVarEnv.reset(); (* In the first part of this function, we typecheck the syntactic declaration [sdecl] in the outer environment [outer_env]. *) let env = outer_env in @@ -1461,8 +1716,8 @@ let transl_with_constraint id ?fixed_row_path ~sig_env ~sig_decl ~outer_env let arity = List.length params in let constraints = List.map (fun (ty, ty', loc) -> - let cty = transl_simple_type env false ty in - let cty' = transl_simple_type env false ty' in + let cty = transl_simple_type env ~closed:false ty in + let cty' = transl_simple_type env ~closed:false ty' in (* Note: We delay the unification of those constraints after the unification of parameters, so that clashing constraints report an error on the constraint location @@ -1472,10 +1727,10 @@ let transl_with_constraint id ?fixed_row_path ~sig_env ~sig_decl ~outer_env in let no_row = not (is_fixed_type sdecl) in let (tman, man) = match sdecl.ptype_manifest with - None -> None, None + None -> Misc.fatal_error "Typedecl.transl_with_constraint: no manifest" | Some sty -> - let cty = transl_simple_type env no_row sty in - Some cty, Some cty.ctyp_type + let cty = transl_simple_type env ~closed:no_row sty in + cty, cty.ctyp_type in (* In the second part, we check the consistency between the two declarations and compute a "merged" declaration; we now need to @@ -1499,26 +1754,27 @@ let transl_with_constraint id ?fixed_row_path ~sig_env ~sig_decl ~outer_env with Ctype.Unify err -> raise(Error(loc, Inconsistent_constraint (env, err))) ) constraints; + let sig_decl_abstract = Btype.type_kind_is_abstract sig_decl in let priv = if sdecl.ptype_private = Private then Private else - if arity_ok && sig_decl.type_kind <> Type_abstract + if arity_ok && not sig_decl_abstract then sig_decl.type_private else sdecl.ptype_private in - if arity_ok && sig_decl.type_kind <> Type_abstract + if arity_ok && not sig_decl_abstract && sdecl.ptype_private = Private then Location.deprecated loc "spurious use of private"; let type_kind, type_unboxed_default = - if arity_ok && man <> None then + if arity_ok then sig_decl.type_kind, sig_decl.type_unboxed_default else - Type_abstract, false + Type_abstract Definition, false in let new_sig_decl = { type_params = params; type_arity = arity; type_kind; type_private = priv; - type_manifest = man; + type_manifest = Some man; type_variance = []; type_separability = Types.Separability.default_signature ~arity; type_is_newtype = false; @@ -1539,7 +1795,7 @@ let transl_with_constraint id ?fixed_row_path ~sig_env ~sig_decl ~outer_env let new_type_variance = let required = Typedecl_variance.variance_of_sdecl sdecl in try - Typedecl_variance.compute_decl env ~check:true new_sig_decl required + Typedecl_variance.compute_decl env ~check:(Some id) new_sig_decl required with Typedecl_variance.Error (loc, err) -> raise (Error (loc, Variance err)) in let new_type_immediate = @@ -1571,8 +1827,6 @@ let transl_with_constraint id ?fixed_row_path ~sig_env ~sig_decl ~outer_env type_immediate = new_type_immediate; type_separability = new_type_separability; } in - Ctype.end_def(); - generalize_decl new_sig_decl; { typ_id = id; typ_name = sdecl.ptype_name; @@ -1580,22 +1834,50 @@ let transl_with_constraint id ?fixed_row_path ~sig_env ~sig_decl ~outer_env typ_type = new_sig_decl; typ_cstrs = constraints; typ_loc = loc; - typ_manifest = tman; + typ_manifest = Some tman; typ_kind = Ttype_abstract; typ_private = sdecl.ptype_private; typ_attributes = sdecl.ptype_attributes; } + end + ~post:(fun ttyp -> generalize_decl ttyp.typ_type) + +(* A simplified version of [transl_with_constraint], for the case of packages. + Package constraints are much simpler than normal with type constraints (e.g., + they can not have parameters and can only update abstract types.) *) +let transl_package_constraint ~loc env ty = + let new_sig_decl = + { type_params = []; + type_arity = 0; + type_kind = Type_abstract Definition; + type_private = Public; + type_manifest = Some ty; + type_variance = []; + type_separability = []; + type_is_newtype = false; + type_expansion_scope = Btype.lowest_level; + type_loc = loc; + type_attributes = []; + type_immediate = Unknown; + type_unboxed_default = false; + type_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) + } + in + let new_type_immediate = + (* Typedecl_immediacy.compute_decl never raises *) + Typedecl_immediacy.compute_decl env new_sig_decl + in + { new_sig_decl with type_immediate = new_type_immediate } (* Approximate a type declaration: just make all types abstract *) let abstract_type_decl ~injective arity = let rec make_params n = if n <= 0 then [] else Ctype.newvar() :: make_params (n-1) in - Ctype.begin_def(); - let decl = + Ctype.with_local_level ~post:generalize_decl begin fun () -> { type_params = make_params arity; type_arity = arity; - type_kind = Type_abstract; + type_kind = Type_abstract Definition; type_private = Public; type_manifest = None; type_variance = Variance.unknown_signature ~injective ~arity; @@ -1607,10 +1889,8 @@ let abstract_type_decl ~injective arity = type_immediate = Unknown; type_unboxed_default = false; type_uid = Uid.internal_not_actually_unique; - } in - Ctype.end_def(); - generalize_decl decl; - decl + } + end let approx_type_decl sdecl_list = let scope = Ctype.create_scope () in @@ -1621,16 +1901,16 @@ let approx_type_decl sdecl_list = abstract_type_decl ~injective (List.length sdecl.ptype_params))) sdecl_list -(* Variant of check_abbrev_recursion to check the well-formedness - conditions on type abbreviations defined within recursive modules. *) +(* Check the well-formedness conditions on type abbreviations defined + within recursive modules. *) let check_recmod_typedecl env loc recmod_ids path decl = (* recmod_ids is the list of recursively-defined module idents. (path, decl) is the type declaration to be checked. *) let to_check path = Path.exists_free recmod_ids path in - check_well_founded_decl env loc path decl to_check; - check_recursion ~orig_env:env env loc path decl to_check; - (* additionally check coherece, as one might build an incoherent signature, + check_well_founded_decl ~abs_env:env env loc path decl to_check; + check_regularity ~abs_env:env env loc path decl to_check; + (* additional coherence check, as one might build an incoherent signature, and use it to build an incoherent module, cf. #7851 *) check_coherence env loc path decl @@ -1638,6 +1918,7 @@ let check_recmod_typedecl env loc recmod_ids path decl = (**** Error report ****) open Format +module Style = Misc.Style let explain_unbound_gen ppf tv tl typ kwd pr = try @@ -1647,7 +1928,8 @@ let explain_unbound_gen ppf tv tl typ kwd pr = Printtyp.prepare_for_printing [typ ti; ty0]; fprintf ppf ".@ @[In %s@ %a@;<1 -2>the variable %a is unbound@]" - kwd pr ti Printtyp.prepared_type_expr tv + kwd (Style.as_inline_code pr) ti + (Style.as_inline_code Printtyp.prepared_type_expr) tv (* kwd pr ti Printtyp.prepared_type_expr tv *) with Not_found -> () @@ -1682,30 +1964,86 @@ let tys_of_constr_args = function | Types.Cstr_tuple tl -> tl | Types.Cstr_record lbls -> List.map (fun l -> l.Types.ld_type) lbls +module Reaching_path = struct + type t = reaching_type_path + + (* Simplify a reaching path before showing it in error messages. *) + let simplify path = + let rec simplify : t -> t = function + | Contains (ty1, _ty2) :: Contains (_ty2', ty3) :: rest -> + (* If t1 contains t2 and t2 contains t3, then t1 contains t3 + and we don't need to show t2. *) + simplify (Contains (ty1, ty3) :: rest) + | hd :: rest -> hd :: simplify rest + | [] -> [] + in simplify path + + (* See Printtyp.add_type_to_preparation. + + Note: it is better to call this after [simplify], otherwise some + type variable names may be used for types that are removed + by simplification and never actually shown to the user. + *) + let add_to_preparation path = + List.iter (function + | Contains (ty1, ty2) | Expands_to (ty1, ty2) -> + List.iter Printtyp.add_type_to_preparation [ty1; ty2] + ) path + + let pp ppf reaching_path = + let pp_step ppf = function + | Expands_to (ty, body) -> + Format.fprintf ppf "%a = %a" + (Style.as_inline_code Printtyp.prepared_type_expr) ty + (Style.as_inline_code Printtyp.prepared_type_expr) body + | Contains (outer, inner) -> + Format.fprintf ppf "%a contains %a" + (Style.as_inline_code Printtyp.prepared_type_expr) outer + (Style.as_inline_code Printtyp.prepared_type_expr) inner + in + let comma ppf () = Format.fprintf ppf ",@ " in + Format.(pp_print_list ~pp_sep:comma pp_step) ppf reaching_path + + let pp_colon ppf path = + Format.fprintf ppf ":@;<1 2>@[%a@]" + pp path +end + let report_error ppf = function | Repeated_parameter -> fprintf ppf "A type parameter occurs several times" | Duplicate_constructor s -> - fprintf ppf "Two constructors are named %s" s + fprintf ppf "Two constructors are named %a" Style.inline_code s | Too_many_constructors -> fprintf ppf "@[Too many non-constant constructors@ -- maximum is %i %s@]" (Config.max_tag + 1) "non-constant constructors" | Duplicate_label s -> - fprintf ppf "Two labels are named %s" s - | Recursive_abbrev s -> - fprintf ppf "The type abbreviation %s is cyclic" s - | Cycle_in_def (s, ty) -> - fprintf ppf "@[The definition of %s contains a cycle:@ %a@]" - s Printtyp.type_expr ty + fprintf ppf "Two labels are named %a" Style.inline_code s + | Recursive_abbrev (s, env, reaching_path) -> + let reaching_path = Reaching_path.simplify reaching_path in + Printtyp.wrap_printing_env ~error:true env @@ fun () -> + Printtyp.reset (); + Reaching_path.add_to_preparation reaching_path; + fprintf ppf "@[The type abbreviation %a is cyclic%a@]" + Style.inline_code s + Reaching_path.pp_colon reaching_path + | Cycle_in_def (s, env, reaching_path) -> + let reaching_path = Reaching_path.simplify reaching_path in + Printtyp.wrap_printing_env ~error:true env @@ fun () -> + Printtyp.reset (); + Reaching_path.add_to_preparation reaching_path; + fprintf ppf "@[The definition of %a contains a cycle%a@]" + Style.inline_code s + Reaching_path.pp_colon reaching_path | Definition_mismatch (ty, _env, None) -> fprintf ppf "@[@[%s@ %s@;<1 2>%a@]@]" "This variant or record definition" "does not match that of type" - Printtyp.type_expr ty + (Style.as_inline_code Printtyp.type_expr) ty | Definition_mismatch (ty, env, Some err) -> fprintf ppf "@[@[%s@ %s@;<1 2>%a@]%a@]" "This variant or record definition" "does not match that of type" - Printtyp.type_expr ty + (Style.as_inline_code Printtyp.type_expr) ty (Includecore.report_type_mismatch "the original" "this" "definition" env) err @@ -1715,40 +2053,26 @@ let report_error ppf = function (fun ppf -> fprintf ppf "Type") (fun ppf -> fprintf ppf "should be an instance of"); fprintf ppf "@]" - | Non_regular { definition; used_as; defined_as; expansions } -> - let pp_expansion ppf (ty,body) = - Format.fprintf ppf "%a = %a" - Printtyp.type_expr ty - Printtyp.type_expr body in - let comma ppf () = Format.fprintf ppf ",@;<1 2>" in - let pp_expansions ppf expansions = - Format.(pp_print_list ~pp_sep:comma pp_expansion) ppf expansions in + | Non_regular { definition; used_as; defined_as; reaching_path } -> + let reaching_path = Reaching_path.simplify reaching_path in + let pp_type ppf ty = Style.as_inline_code !Oprint.out_type ppf ty in Printtyp.prepare_for_printing [used_as; defined_as]; - Printtyp.Naming_context.reset (); - begin match expansions with - | [] -> - fprintf ppf - "@[This recursive type is not regular.@ \ - The type constructor %s is defined as@;<1 2>type %a@ \ - but it is used as@;<1 2>%a.@ \ - All uses need to match the definition for the recursive type \ - to be regular.@]" - (Path.name definition) - !Oprint.out_type (Printtyp.tree_of_typexp Type defined_as) - !Oprint.out_type (Printtyp.tree_of_typexp Type used_as) - | _ :: _ -> - fprintf ppf - "@[This recursive type is not regular.@ \ - The type constructor %s is defined as@;<1 2>type %a@ \ - but it is used as@;<1 2>%a@ \ - after the following expansion(s):@;<1 2>%a@ \ - All uses need to match the definition for the recursive type \ - to be regular.@]" - (Path.name definition) - !Oprint.out_type (Printtyp.tree_of_typexp Type defined_as) - !Oprint.out_type (Printtyp.tree_of_typexp Type used_as) - pp_expansions expansions - end + Reaching_path.add_to_preparation reaching_path; + fprintf ppf + "@[This recursive type is not regular.@ \ + The type constructor %a is defined as@;<1 2>type %a@ \ + but it is used as@;<1 2>%a%t\ + All uses need to match the definition for the recursive type \ + to be regular.@]" + Style.inline_code (Path.name definition) + pp_type (Printtyp.tree_of_typexp Type defined_as) + pp_type (Printtyp.tree_of_typexp Type used_as) + (fun pp -> + let is_expansion = function Expands_to _ -> true | _ -> false in + if List.exists is_expansion reaching_path then + fprintf pp "@ after the following expansion(s)%a@ " + Reaching_path.pp_colon reaching_path + else fprintf pp ".@ ") | Inconsistent_constraint (env, err) -> fprintf ppf "@[The type constraints are not consistent.@ "; Printtyp.report_unification_error ppf env err @@ -1772,17 +2096,17 @@ let report_error ppf = function begin match decl.type_kind, decl.type_manifest with | Type_variant (tl, _rep), _ -> explain_unbound_gen ppf ty tl (fun c -> - let tl = tys_of_constr_args c.Types.cd_args in - Btype.newgenty (Ttuple tl) - ) + let tl = tys_of_constr_args c.Types.cd_args in + Btype.newgenty (Ttuple tl) + ) "case" (fun ppf c -> - fprintf ppf - "%a of %a" Printtyp.ident c.Types.cd_id - Printtyp.constructor_arguments c.Types.cd_args) + fprintf ppf + "%a of %a" Printtyp.ident c.Types.cd_id + Printtyp.constructor_arguments c.Types.cd_args) | Type_record (tl, _), _ -> explain_unbound ppf ty tl (fun l -> l.Types.ld_type) "field" (fun l -> Ident.name l.Types.ld_id ^ ": ") - | Type_abstract, Some ty' -> + | Type_abstract _, Some ty' -> explain_unbound_single ppf ty ty' | _ -> () end; @@ -1799,12 +2123,12 @@ let report_error ppf = function | Not_extensible_type path -> fprintf ppf "@[%s@ %a@ %s@]" "Type definition" - Printtyp.path path + (Style.as_inline_code Printtyp.path) path "is not extensible" | Extension_mismatch (path, env, err) -> - fprintf ppf "@[@[%s@ %s@;<1 2>%s@]%a@]" + fprintf ppf "@[@[%s@ %s@;<1 2>%a@]%a@]" "This extension" "does not match the definition of type" - (Path.name path) + Style.inline_code (Path.name path) (Includecore.report_type_mismatch "the type" "this extension" "definition" env) err @@ -1812,20 +2136,21 @@ let report_error ppf = function Printtyp.report_unification_error ppf env err (function ppf -> fprintf ppf "The constructor %a@ has type" - Printtyp.longident lid) + (Style.as_inline_code Printtyp.longident) lid) (function ppf -> fprintf ppf "but was expected to be of type") | Rebind_mismatch (lid, p, p') -> fprintf ppf - "@[%s@ %a@ %s@ %s@ %s@ %s@ %s@]" - "The constructor" Printtyp.longident lid - "extends type" (Path.name p) + "@[%s@ %a@ %s@ %a@ %s@ %s@ %a@]" + "The constructor" + (Style.as_inline_code Printtyp.longident) lid + "extends type" Style.inline_code (Path.name p) "whose declaration does not match" - "the declaration of type" (Path.name p') + "the declaration of type" Style.inline_code (Path.name p') | Rebind_private lid -> fprintf ppf "@[%s@ %a@ %s@]" "The constructor" - Printtyp.longident lid + (Style.as_inline_code Printtyp.longident) lid "is private" | Variance (Typedecl_variance.Bad_variance (n, v1, v2)) -> let variance (p,n,i) = @@ -1837,30 +2162,61 @@ let report_error ppf = function | false, false -> if inj = "" then "unrestricted" else inj in (match n with - | Variance_not_reflected -> - fprintf ppf "@[%s@ %s@ It" - "In this definition, a type variable has a variance that" - "is not reflected by its occurrence in type parameters." - | No_variable -> - fprintf ppf "@[%s@ %s@]" - "In this definition, a type variable cannot be deduced" - "from the type parameters." - | Variance_not_deducible -> - fprintf ppf "@[%s@ %s@ It" - "In this definition, a type variable has a variance that" - "cannot be deduced from the type parameters." + | Variance_variable_error { error; variable; context } -> + Printtyp.prepare_for_printing [ variable ]; + begin match context with + | Type_declaration (id, decl) -> + Printtyp.add_type_declaration_to_preparation id decl; + fprintf ppf "@[%s@;<1 2>%a@;" + "In the definition" + (Style.as_inline_code @@ Printtyp.prepared_type_declaration id) + decl + | Gadt_constructor c -> + Printtyp.add_constructor_to_preparation c; + fprintf ppf "@[%s@;<1 2>%a@;" + "In the GADT constructor" + (Style.as_inline_code Printtyp.prepared_constructor) + c + | Extension_constructor (id, e) -> + Printtyp.add_extension_constructor_to_preparation e; + fprintf ppf "@[%s@;<1 2>%a@;" + "In the extension constructor" + (Printtyp.prepared_extension_constructor id) + e + end; + begin match error with + | Variance_not_reflected -> + fprintf ppf "@[%s@ %a@ %s@ %s@ It" + "the type variable" + (Style.as_inline_code Printtyp.prepared_type_expr) variable + "has a variance that" + "is not reflected by its occurrence in type parameters." + | No_variable -> + fprintf ppf "@[%s@ %a@ %s@ %s@]@]" + "the type variable" + (Style.as_inline_code Printtyp.prepared_type_expr) variable + "cannot be deduced" + "from the type parameters." + | Variance_not_deducible -> + fprintf ppf "@[%s@ %a@ %s@ %s@ It" + "the type variable" + (Style.as_inline_code Printtyp.prepared_type_expr) variable + "has a variance that" + "cannot be deduced from the type parameters." + end | Variance_not_satisfied n -> - fprintf ppf "@[%s@ %s@ The %d%s type parameter" + fprintf ppf "@[@[%s@ %s@ The %d%s type parameter" "In this definition, expected parameter" "variances are not satisfied." n (Misc.ordinal_suffix n)); (match n with - | No_variable -> () + | Variance_variable_error { error = No_variable; _ } -> () | _ -> - fprintf ppf " was expected to be %s,@ but it is %s.@]" + fprintf ppf " was expected to be %s,@ but it is %s.@]@]" (variance v2) (variance v1)) | Unavailable_type_constructor p -> - fprintf ppf "The definition of type %a@ is unavailable" Printtyp.path p + fprintf ppf "The definition of type %a@ is unavailable" + (Style.as_inline_code Printtyp.path) p | Variance Typedecl_variance.Varying_anonymous -> fprintf ppf "@[%s@ %s@ %s@]" "In this GADT definition," "the variance of some parameter" @@ -1868,28 +2224,42 @@ let report_error ppf = function | Val_in_structure -> fprintf ppf "Value declarations are only allowed in signatures" | Multiple_native_repr_attributes -> - fprintf ppf "Too many [@@unboxed]/[@@untagged] attributes" + fprintf ppf "Too many %a/%a attributes" + Style.inline_code "[@@unboxed]" + Style.inline_code "[@@untagged]" | Cannot_unbox_or_untag_type Unboxed -> fprintf ppf "@[Don't know how to unbox this type.@ \ - Only float, int32, int64 and nativeint can be unboxed.@]" + Only %a, %a, %a, and %a can be unboxed.@]" + Style.inline_code "float" + Style.inline_code "int32" + Style.inline_code "int64" + Style.inline_code "nativeint" | Cannot_unbox_or_untag_type Untagged -> - fprintf ppf "@[Don't know how to untag this type.@ \ - Only int can be untagged.@]" + fprintf ppf "@[Don't know how to untag this type. Only %a@ \ + and other immediate types can be untagged.@]" + Style.inline_code "int" | Deep_unbox_or_untag_attribute kind -> fprintf ppf - "@[The attribute '%s' should be attached to@ \ + "@[The attribute %a should be attached to@ \ a direct argument or result of the primitive,@ \ it should not occur deeply into its type.@]" + Style.inline_code (match kind with Unboxed -> "@unboxed" | Untagged -> "@untagged") | Immediacy (Typedecl_immediacy.Bad_immediacy_attribute violation) -> - fprintf ppf "@[%a@]" Format.pp_print_text - (match violation with - | Type_immediacy.Violation.Not_always_immediate -> - "Types marked with the immediate attribute must be \ - non-pointer types like int or bool." - | Type_immediacy.Violation.Not_always_immediate_on_64bits -> - "Types marked with the immediate64 attribute must be \ - produced using the Stdlib.Sys.Immediate64.Make functor.") + (match violation with + | Type_immediacy.Violation.Not_always_immediate -> + fprintf ppf + "@[Types@ marked@ with@ the@ immediate@ attribute@ must@ be@ \ + non-pointer@ types@ like@ %a@ or@ %a.@]" + Style.inline_code "int" + Style.inline_code "bool" + | Type_immediacy.Violation.Not_always_immediate_on_64bits -> + fprintf ppf + "@[Types@ marked@ with@ the@ %a@ attribute@ must@ be@ \ + produced@ using@ the@ %a@ functor.@]" + Style.inline_code "immediate64" + Style.inline_code "Stdlib.Sys.Immediate64.Make" + ) | Bad_unboxed_attribute msg -> fprintf ppf "@[This type cannot be unboxed because@ %s.@]" msg | Separability (Typedecl_separability.Non_separable_evar evar) -> @@ -1898,25 +2268,30 @@ let report_error ppf = function fprintf ppf "an unnamed existential variable" | Some str -> fprintf ppf "the existential variable %a" - Pprintast.tyvar str in + (Style.as_inline_code Pprintast.tyvar) str in fprintf ppf "@[This type cannot be unboxed because@ \ it might contain both float and non-float values,@ \ depending on the instantiation of %a.@ \ - You should annotate it with [%@%@ocaml.boxed].@]" + You should annotate it with %a.@]" pp_evar evar + Style.inline_code "[@@ocaml.boxed]" | Boxed_and_unboxed -> fprintf ppf "@[A type cannot be boxed and unboxed at the same time.@]" | Nonrec_gadt -> fprintf ppf - "@[GADT case syntax cannot be used in a 'nonrec' block.@]" + "@[GADT case syntax cannot be used in a %a block.@]" + Style.inline_code "nonrec" | Invalid_private_row_declaration ty -> + let pp_private ppf ty = fprintf ppf "private %a" Printtyp.type_expr ty in Format.fprintf ppf "@[This private row type declaration is invalid.@ \ The type expression on the right-hand side reduces to@;<1 2>%a@ \ which does not have a free row type variable.@]@,\ - @[@[Hint: If you intended to define a private type abbreviation,@ \ - write explicitly@]@;<1 2>private %a@]" - Printtyp.type_expr ty Printtyp.type_expr ty + @[@[@{Hint@}: If you intended to define a private \ + type abbreviation,@ \ + write explicitly@]@;<1 2>%a@]" + (Style.as_inline_code Printtyp.type_expr) ty + (Style.as_inline_code pp_private) ty let () = Location.register_error_of_exn diff --git a/src/ocaml/typing/typedecl.mli b/src/ocaml/typing/typedecl.mli index 0fb68edf42..52a3197f74 100644 --- a/src/ocaml/typing/typedecl.mli +++ b/src/ocaml/typing/typedecl.mli @@ -20,19 +20,19 @@ open Format val transl_type_decl: Env.t -> Asttypes.rec_flag -> Parsetree.type_declaration list -> - Typedtree.type_declaration list * Env.t + Typedtree.type_declaration list * Env.t * Shape.t list val transl_exception: Env.t -> Parsetree.extension_constructor -> - Typedtree.extension_constructor * Env.t + Typedtree.extension_constructor * Env.t * Shape.t val transl_type_exception: Env.t -> - Parsetree.type_exception -> Typedtree.type_exception * Env.t + Parsetree.type_exception -> Typedtree.type_exception * Env.t * Shape.t val transl_type_extension: bool -> Env.t -> Location.t -> Parsetree.type_extension -> - Typedtree.type_extension * Env.t + Typedtree.type_extension * Env.t * Shape.t list val transl_value_decl: Env.t -> Location.t -> @@ -46,6 +46,9 @@ val transl_with_constraint: outer_env:Env.t -> Parsetree.type_declaration -> Typedtree.type_declaration +val transl_package_constraint: + loc:Location.t -> Env.t -> type_expr -> Types.type_declaration + val abstract_type_decl: injective:bool -> int -> type_declaration val approx_type_decl: Parsetree.type_declaration list -> @@ -60,13 +63,18 @@ val is_fixed_type : Parsetree.type_declaration -> bool type native_repr_kind = Unboxed | Untagged +type reaching_type_path = reaching_type_step list +and reaching_type_step = + | Expands_to of type_expr * type_expr + | Contains of type_expr * type_expr + type error = Repeated_parameter | Duplicate_constructor of string | Too_many_constructors | Duplicate_label of string - | Recursive_abbrev of string - | Cycle_in_def of string * type_expr + | Recursive_abbrev of string * Env.t * reaching_type_path + | Cycle_in_def of string * Env.t * reaching_type_path | Definition_mismatch of type_expr * Env.t * Includecore.type_mismatch option | Constraint_failed of Env.t * Errortrace.unification_error | Inconsistent_constraint of Env.t * Errortrace.unification_error @@ -75,7 +83,7 @@ type error = definition: Path.t; used_as: type_expr; defined_as: type_expr; - expansions: (type_expr * type_expr) list; + reaching_path: reaching_type_path; } | Null_arity_external | Missing_native_external diff --git a/src/ocaml/typing/typedecl_immediacy.ml b/src/ocaml/typing/typedecl_immediacy.ml index 4a57f37cf9..71e49a10be 100644 --- a/src/ocaml/typing/typedecl_immediacy.ml +++ b/src/ocaml/typing/typedecl_immediacy.ml @@ -29,14 +29,15 @@ let compute_decl env tdecl = | None -> Type_immediacy.Unknown | Some argrepr -> Ctype.immediacy env argrepr end - | (Type_variant (_ :: _ as cstrs, _), _) -> + | (Type_variant (cstrs, _), _) -> if not (List.exists (fun c -> c.Types.cd_args <> Types.Cstr_tuple []) cstrs) then Type_immediacy.Always else Type_immediacy.Unknown - | (Type_abstract, Some(typ)) -> Ctype.immediacy env typ - | (Type_abstract, None) -> Type_immediacy.of_attributes tdecl.type_attributes + | (Type_abstract _, Some(typ)) -> Ctype.immediacy env typ + | (Type_abstract _, None) -> + Type_immediacy.of_attributes tdecl.type_attributes | _ -> Type_immediacy.Unknown let property : (Type_immediacy.t, unit) Typedecl_properties.property = diff --git a/src/ocaml/typing/typedecl_separability.ml b/src/ocaml/typing/typedecl_separability.ml index c6ded4cf6a..c8f2f3b171 100644 --- a/src/ocaml/typing/typedecl_separability.ml +++ b/src/ocaml/typing/typedecl_separability.ml @@ -50,7 +50,7 @@ type type_structure = let structure : type_definition -> type_structure = fun def -> match def.type_kind with | Type_open -> Open - | Type_abstract -> + | Type_abstract _ -> begin match def.type_manifest with | None -> Abstract | Some type_expr -> Synonym type_expr diff --git a/src/ocaml/typing/typedecl_unboxed.ml b/src/ocaml/typing/typedecl_unboxed.ml index 10aaa0c523..16290f0fbb 100644 --- a/src/ocaml/typing/typedecl_unboxed.ml +++ b/src/ocaml/typing/typedecl_unboxed.ml @@ -41,4 +41,3 @@ let rec get_unboxed_type_representation env ty fuel = let get_unboxed_type_representation env ty = (* Do not give too much fuel: PR#7424 *) get_unboxed_type_representation env ty 100 -;; diff --git a/src/ocaml/typing/typedecl_variance.ml b/src/ocaml/typing/typedecl_variance.ml index 05b0c2eba6..c384e8c467 100644 --- a/src/ocaml/typing/typedecl_variance.ml +++ b/src/ocaml/typing/typedecl_variance.ml @@ -22,15 +22,27 @@ module TypeMap = Btype.TypeMap type surface_variance = bool * bool * bool +type variance_variable_context = + | Type_declaration of Ident.t * type_declaration + | Gadt_constructor of constructor_declaration + | Extension_constructor of Ident.t * extension_constructor + +type variance_variable_error = + | No_variable + | Variance_not_reflected + | Variance_not_deducible + type variance_error = -| Variance_not_satisfied of int -| No_variable -| Variance_not_reflected -| Variance_not_deducible + | Variance_not_satisfied of int + | Variance_variable_error of { + error : variance_variable_error; + context : variance_variable_context; + variable : type_expr + } type error = -| Bad_variance of variance_error * surface_variance * surface_variance -| Varying_anonymous + | Bad_variance of variance_error * surface_variance * surface_variance + | Varying_anonymous exception Error of Location.t * error @@ -50,13 +62,7 @@ let compute_variance env visited vari ty = let compute_same = compute_variance_rec vari in match get_desc ty with Tarrow (_, ty1, ty2, _) -> - let open Variance in - let v = conjugate vari in - let v1 = - if mem May_pos v || mem May_neg v - then set May_weak true v else v - in - compute_variance_rec v1 ty1; + compute_variance_rec (Variance.conjugate vari) ty1; compute_same ty2 | Ttuple tl -> List.iter compute_same tl @@ -65,25 +71,8 @@ let compute_variance env visited vari ty = if tl = [] then () else begin try let decl = Env.find_type path env in - let cvari f = mem f vari in List.iter2 - (fun ty v -> - let cv f = mem f v in - let strict = - cvari Inv && cv Inj || (cvari Pos || cvari Neg) && cv Inv - in - if strict then compute_variance_rec full ty else - let p1 = inter v vari - and n1 = inter v (conjugate vari) in - let v1 = - union (inter covariant (union p1 (conjugate p1))) - (inter (conjugate covariant) (union n1 (conjugate n1))) - and weak = - cvari May_weak && (cv May_pos || cv May_neg) || - (cvari May_pos || cvari May_neg) && cv May_weak - in - let v2 = set May_weak weak v1 in - compute_variance_rec v2 ty) + (fun ty v -> compute_variance_rec (compose vari v) ty) tl decl.type_variance with Not_found -> List.iter (compute_variance_rec unknown) tl @@ -102,14 +91,7 @@ let compute_variance env visited vari ty = Rpresent (Some ty) -> compute_same ty | Reither (_, tyl, _) -> - let open Variance in - let upper = - List.fold_left (fun s f -> set f true s) - null [May_pos; May_neg; May_weak] - in - let v = inter vari upper in - (* cf PR#7269: - if List.length tyl > 1 then upper else inter vari upper *) + let v = Variance.(inter vari unknown) in (* cf PR#7269 *) List.iter (compute_variance_rec v) tyl | _ -> ()) (row_fields row); @@ -118,22 +100,20 @@ let compute_variance env visited vari ty = compute_same ty | Tvar _ | Tnil | Tlink _ | Tunivar _ -> () | Tpackage (_, fl) -> - let v = - Variance.(if mem Pos vari || mem Neg vari then full else unknown) - in + let v = Variance.(compose vari full) in List.iter (fun (_, ty) -> compute_variance_rec v ty) fl in compute_variance_rec vari ty let make p n i = let open Variance in - set May_pos p (set May_neg n (set May_weak n (set Inj i null))) + set_if p May_pos (set_if n May_neg (set_if i Inj null)) -let injective = Variance.(set Inj true null) +let injective = Variance.(set Inj null) let compute_variance_type env ~check (required, loc) decl tyl = (* Requirements *) - let check_injectivity = decl.type_kind = Type_abstract in + let check_injectivity = Btype.type_kind_is_abstract decl in let required = List.map (fun (c,n,i) -> @@ -177,7 +157,9 @@ let compute_variance_type env ~check (required, loc) decl tyl = try check ty; compute_variance env tvl injective ty with Exit -> ()) params; - if check then begin + begin match check with + | None -> () + | Some context -> (* Check variance of parameters *) let pos = ref 0 in List.iter2 @@ -219,38 +201,46 @@ let compute_variance_type env ~check (required, loc) decl tyl = if Ctype.is_equal env false [ty] [t] then union vt v else v) !tvl2 null in Btype.backtrack snap; - let (c1,n1) = get_upper v1 and (c2,n2,_,i2) = get_lower v2 in - if c1 && not c2 || n1 && not n2 then - if List.exists (eq_type ty) fvl then - let code = if not i2 then No_variable - else if c2 || n2 then Variance_not_reflected - else Variance_not_deducible in - raise (Error (loc, Bad_variance (code, (c1,n1,false), (c2,n2,false)))) - else - Btype.iter_type_expr check ty + let (c1,n1) = get_upper v1 and (c2,n2,i2) = get_lower v2 in + if c1 && not c2 || n1 && not n2 then begin + match List.find_opt (eq_type ty) fvl with + | Some variable -> + let error = + if not i2 then + No_variable + else if c2 || n2 then + Variance_not_reflected + else + Variance_not_deducible + in + let variance_error = + Variance_variable_error { error; context; variable } + in + raise + (Error (loc + , Bad_variance ( variance_error + , (c1,n1,false) + , (c2,n2,false)))) + | None -> + Btype.iter_type_expr check ty + end in List.iter (fun (_,ty) -> check ty) tyl; end; List.map2 - (fun ty (p, n, i) -> + (fun ty (p, n, _i) -> let v = get_variance ty tvl in let tr = decl.type_private in (* Use required variance where relevant *) - let concr = decl.type_kind <> Type_abstract (*|| tr = Type_new*) in + let concr = not (Btype.type_kind_is_abstract decl) in let (p, n) = if tr = Private || not (Btype.is_Tvar ty) then (p, n) (* set *) else (false, false) (* only check *) - and i = concr || i && tr = Private in + and i = concr in let v = union v (make p n i) in - let v = - if not concr then v else - if mem Pos v && mem Neg v then full else - if Btype.is_Tvar ty then v else - union v - (if p then if n then full else covariant else conjugate covariant) - in - if decl.type_kind = Type_abstract && tr = Public then v else - set May_weak (mem May_neg v) v) + if not concr || Btype.is_Tvar ty then v else + union v + (if p then if n then full else covariant else conjugate covariant)) params required let add_false = List.map (fun ty -> false, ty) @@ -296,49 +286,77 @@ let compute_variance_gadt env ~check (required, loc as rloc) decl (for_constr tl) | _ -> assert false -let compute_variance_extension env ~check decl ext rloc = +let compute_variance_extension env decl ext rloc = + let check = + Some (Extension_constructor (ext.Typedtree.ext_id, ext.Typedtree.ext_type)) + in + let ext = ext.Typedtree.ext_type in compute_variance_gadt env ~check rloc {decl with type_params = ext.ext_type_params} (ext.ext_args, ext.ext_ret_type) +let compute_variance_gadt_constructor env ~check rloc decl tl = + let check = + match check with + | Some _ -> Some (Gadt_constructor tl) + | None -> None + in + compute_variance_gadt env ~check rloc decl + (tl.Types.cd_args, tl.Types.cd_res) + let compute_variance_decl env ~check decl (required, _ as rloc) = - if (decl.type_kind = Type_abstract || decl.type_kind = Type_open) - && decl.type_manifest = None then + let check = + Option.map (fun id -> Type_declaration (id, decl)) check + in + let abstract = Btype.type_kind_is_abstract decl in + if (abstract || decl.type_kind = Type_open) && decl.type_manifest = None then List.map - (fun (c, n, i) -> - make (not n) (not c) (decl.type_kind <> Type_abstract || i)) + (fun (c, n, i) -> make (not n) (not c) (not abstract || i)) required - else - let mn = - match decl.type_manifest with - None -> [] - | Some ty -> [false, ty] - in - match decl.type_kind with - Type_abstract | Type_open -> - compute_variance_type env ~check rloc decl mn - | Type_variant (tll,_rep) -> - if List.for_all (fun c -> c.Types.cd_res = None) tll then - compute_variance_type env ~check rloc decl - (mn @ List.flatten (List.map (fun c -> for_constr c.Types.cd_args) - tll)) - else begin - let mn = - List.map (fun (_,ty) -> (Types.Cstr_tuple [ty],None)) mn in - let tll = - mn @ List.map (fun c -> c.Types.cd_args, c.Types.cd_res) tll in - match List.map (compute_variance_gadt env ~check rloc decl) tll with - | vari :: rem -> - let varl = List.fold_left (List.map2 Variance.union) vari rem in - List.map - Variance.(fun v -> if mem Pos v && mem Neg v then full else v) - varl - | _ -> assert false - end - | Type_record (ftl, _) -> - compute_variance_type env ~check rloc decl - (mn @ List.map (fun {Types.ld_mutable; ld_type} -> - (ld_mutable = Mutable, ld_type)) ftl) + else begin + let mn = + match decl.type_manifest with + None -> [] + | Some ty -> [ false, ty ] + in + let vari = + match decl.type_kind with + Type_abstract _ | Type_open -> + compute_variance_type env ~check rloc decl mn + | Type_variant (tll,_rep) -> + if List.for_all (fun c -> c.Types.cd_res = None) tll then + compute_variance_type env ~check rloc decl + (mn @ List.flatten (List.map (fun c -> for_constr c.Types.cd_args) + tll)) + else begin + let vari = + List.map + (fun ty -> + compute_variance_type env ~check rloc + {decl with type_private = Private} + (add_false [ ty ]) + ) + (Option.to_list decl.type_manifest) + in + let constructor_variance = + List.map + (compute_variance_gadt_constructor env ~check rloc decl) + tll + in + match List.append vari constructor_variance with + | vari :: rem -> + List.fold_left (List.map2 Variance.union) vari rem + | _ -> assert false + end + | Type_record (ftl, _) -> + compute_variance_type env ~check rloc decl + (mn @ List.map (fun {Types.ld_mutable; ld_type} -> + (ld_mutable = Mutable, ld_type)) ftl) + in + if mn = [] || not abstract then + List.map Variance.strengthen vari + else vari + end let is_hash id = let s = Ident.name id in @@ -346,14 +364,13 @@ let is_hash id = let check_variance_extension env decl ext rloc = (* TODO: refactorize compute_variance_extension *) - ignore (compute_variance_extension env ~check:true decl - ext.Typedtree.ext_type rloc) + ignore (compute_variance_extension env decl ext rloc) let compute_decl env ~check decl req = compute_variance_decl env ~check decl (req, decl.type_loc) -let check_decl env decl req = - ignore (compute_variance_decl env ~check:true decl (req, decl.type_loc)) +let check_decl env id decl req = + ignore (compute_variance_decl env ~check:(Some id) decl (req, decl.type_loc)) type prop = Variance.t list type req = surface_variance list @@ -366,11 +383,11 @@ let property : (prop, req) Typedecl_properties.property = let default decl = List.map (fun _ -> Variance.null) decl.type_params in let compute env decl req = - compute_decl env ~check:false decl req in + compute_decl env ~check:None decl req in let update_decl decl variance = { decl with type_variance = variance } in let check env id decl req = - if is_hash id then () else check_decl env decl req in + if is_hash id then () else check_decl env id decl req in { eq; merge; @@ -402,7 +419,7 @@ let update_decls env sdecls decls = let update_class_decls env cldecls = let decls, required = List.fold_right - (fun (obj_id, obj_abbr, _cl_abbr, _clty, _cltydef, ci) (decls, req) -> + (fun (obj_id, obj_abbr, _clty, _cltydef, ci) (decls, req) -> (obj_id, obj_abbr) :: decls, variance_of_params ci.Typedtree.ci_params :: req) cldecls ([],[]) @@ -410,9 +427,11 @@ let update_class_decls env cldecls = let decls = Typedecl_properties.compute_property property env decls required in List.map2 - (fun (_,decl) (_, _, cl_abbr, clty, cltydef, _) -> + (fun (_,decl) (_, _, clty, cltydef, _) -> let variance = decl.type_variance in - (decl, {cl_abbr with type_variance = variance}, - {clty with cty_variance = variance}, - {cltydef with clty_variance = variance})) + (decl, {clty with cty_variance = variance}, + {cltydef with + clty_variance = variance; + clty_hash_type = {cltydef.clty_hash_type with type_variance = variance} + })) decls cldecls diff --git a/src/ocaml/typing/typedecl_variance.mli b/src/ocaml/typing/typedecl_variance.mli index 941ab99299..6392e61dd1 100644 --- a/src/ocaml/typing/typedecl_variance.mli +++ b/src/ocaml/typing/typedecl_variance.mli @@ -29,15 +29,27 @@ type prop = Variance.t list type req = surface_variance list val property : (Variance.t list, req) property +type variance_variable_context = + | Type_declaration of Ident.t * type_declaration + | Gadt_constructor of constructor_declaration + | Extension_constructor of Ident.t * extension_constructor + +type variance_variable_error = + | No_variable + | Variance_not_reflected + | Variance_not_deducible + type variance_error = -| Variance_not_satisfied of int -| No_variable -| Variance_not_reflected -| Variance_not_deducible + | Variance_not_satisfied of int + | Variance_variable_error of { + error : variance_variable_error; + context : variance_variable_context; + variable : type_expr + } type error = -| Bad_variance of variance_error * surface_variance * surface_variance -| Varying_anonymous + | Bad_variance of variance_error * surface_variance * surface_variance + | Varying_anonymous exception Error of Location.t * error @@ -46,7 +58,7 @@ val check_variance_extension : Typedtree.extension_constructor -> req * Location.t -> unit val compute_decl : - Env.t -> check:bool -> type_declaration -> req -> prop + Env.t -> check:Ident.t option -> type_declaration -> req -> prop val update_decls : Env.t -> Parsetree.type_declaration list -> @@ -55,9 +67,9 @@ val update_decls : val update_class_decls : Env.t -> - (Ident.t * Typedecl_properties.decl * Types.type_declaration * + (Ident.t * Typedecl_properties.decl * Types.class_declaration * Types.class_type_declaration * 'a Typedtree.class_infos) list -> - (Typedecl_properties.decl * Types.type_declaration * + (Typedecl_properties.decl * Types.class_declaration * Types.class_type_declaration) list (* FIXME: improve this horrible interface *) diff --git a/src/ocaml/typing/typedtree.ml b/src/ocaml/typing/typedtree.ml index 19c3e15e83..4080b14606 100644 --- a/src/ocaml/typing/typedtree.ml +++ b/src/ocaml/typing/typedtree.ml @@ -18,6 +18,8 @@ open Asttypes open Types +module Uid = Shape.Uid + (* Value expressions for the core language *) type partial = Partial | Total @@ -53,9 +55,9 @@ and pat_extra = and 'k pattern_desc = (* value patterns *) | Tpat_any : value pattern_desc - | Tpat_var : Ident.t * string loc -> value pattern_desc + | Tpat_var : Ident.t * string loc * Uid.t -> value pattern_desc | Tpat_alias : - value general_pattern * Ident.t * string loc -> value pattern_desc + value general_pattern * Ident.t * string loc * Uid.t -> value pattern_desc | Tpat_constant : constant -> value pattern_desc | Tpat_tuple : value general_pattern list -> value pattern_desc | Tpat_construct : @@ -95,14 +97,13 @@ and exp_extra = | Texp_coerce of core_type option * core_type | Texp_poly of core_type option | Texp_newtype of string - | Texp_newtype' of Ident.t * label loc + | Texp_newtype' of Ident.t * label loc * Uid.t and expression_desc = Texp_ident of Path.t * Longident.t loc * Types.value_description | Texp_constant of constant | Texp_let of rec_flag * value_binding list * expression - | Texp_function of { arg_label : arg_label; param : Ident.t; - cases : value case list; partial : partial; } + | Texp_function of function_param list * function_body | Texp_apply of expression * (arg_label * expression option) list | Texp_match of expression * computation case list * partial | Texp_try of expression * value case list @@ -134,7 +135,7 @@ and expression_desc = Ident.t option * string option loc * Types.module_presence * module_expr * expression | Texp_letexception of extension_constructor * expression - | Texp_assert of expression + | Texp_assert of expression * Location.t | Texp_lazy of expression | Texp_object of class_structure * string list | Texp_pack of module_expr @@ -162,8 +163,33 @@ and 'k case = c_rhs: expression; } +and function_param = + { + fp_arg_label: arg_label; + fp_param: Ident.t; + fp_partial: partial; + fp_kind: function_param_kind; + fp_newtypes: string loc list; + fp_loc : Location.t; + } + +and function_param_kind = + | Tparam_pat of pattern + | Tparam_optional_default of pattern * expression + +and function_body = + | Tfunction_body of expression + | Tfunction_cases of + { cases: value case list; + partial: partial; + param: Ident.t; + loc: Location.t; + exp_extra: exp_extra option; + attributes: attributes; + } + and record_label_definition = - | Kept of Types.type_expr + | Kept of Types.type_expr * mutable_flag | Overridden of Longident.t loc * expression and binding_op = @@ -254,6 +280,7 @@ and module_expr_desc = | Tmod_structure of structure | Tmod_functor of functor_parameter * module_expr | Tmod_apply of module_expr * module_expr * module_coercion + | Tmod_apply_unit of module_expr | Tmod_constraint of module_expr * Types.module_type * module_type_constraint * module_coercion | Tmod_unpack of expression * Types.module_type @@ -291,6 +318,7 @@ and module_binding = { mb_id: Ident.t option; mb_name: string option loc; + mb_uid: Uid.t; mb_presence: module_presence; mb_expr: module_expr; mb_attributes: attribute list; @@ -301,6 +329,7 @@ and value_binding = { vb_pat: pattern; vb_expr: expression; + vb_rec_kind: Value_rec_types.recursive_binding_kind; vb_attributes: attributes; vb_loc: Location.t; } @@ -370,6 +399,7 @@ and module_declaration = { md_id: Ident.t option; md_name: string option loc; + md_uid: Uid.t; md_presence: module_presence; md_type: module_type; md_attributes: attribute list; @@ -380,6 +410,7 @@ and module_substitution = { ms_id: Ident.t; ms_name: string loc; + ms_uid: Uid.t; ms_manifest: Path.t; ms_txt: Longident.t loc; ms_attributes: attributes; @@ -390,6 +421,7 @@ and module_type_declaration = { mtd_id: Ident.t; mtd_name: string loc; + mtd_uid: Uid.t; mtd_type: module_type option; mtd_attributes: attribute list; mtd_loc: Location.t; @@ -447,10 +479,11 @@ and core_type_desc = | Ttyp_constr of Path.t * Longident.t loc * core_type list | Ttyp_object of object_field list * closed_flag | Ttyp_class of Path.t * Longident.t loc * core_type list - | Ttyp_alias of core_type * string + | Ttyp_alias of core_type * string loc | Ttyp_variant of row_field list * closed_flag * label list option | Ttyp_poly of string list * core_type | Ttyp_package of package_type + | Ttyp_open of Path.t * Longident.t loc * core_type and package_type = { pack_path : Path.t; @@ -512,6 +545,7 @@ and label_declaration = { ld_id: Ident.t; ld_name: string loc; + ld_uid: Uid.t; ld_mutable: mutable_flag; ld_type: core_type; ld_loc: Location.t; @@ -522,6 +556,7 @@ and constructor_declaration = { cd_id: Ident.t; cd_name: string loc; + cd_uid: Uid.t; cd_vars: string loc list; cd_args: constructor_arguments; cd_res: core_type option; @@ -615,7 +650,6 @@ and 'a class_infos = ci_id_class: Ident.t; ci_id_class_type: Ident.t; ci_id_object: Ident.t; - ci_id_typehash: Ident.t; ci_expr: 'a; ci_decl: Types.class_declaration; ci_type_decl: Types.class_type_declaration; @@ -630,6 +664,19 @@ type implementation = { shape: Shape.t; } +type item_declaration = + | Value of value_description + | Value_binding of value_binding + | Type of type_declaration + | Constructor of constructor_declaration + | Extension_constructor of extension_constructor + | Label of label_declaration + | Module of module_declaration + | Module_substitution of module_substitution + | Module_binding of module_binding + | Module_type of module_type_declaration + | Class of class_declaration + | Class_type of class_type_declaration (* Auxiliary functions over the a.s.t. *) @@ -675,7 +722,7 @@ type pattern_action = let shallow_iter_pattern_desc : type k . pattern_action -> k pattern_desc -> unit = fun f -> function - | Tpat_alias(p, _, _) -> f.f p + | Tpat_alias(p, _, _, _) -> f.f p | Tpat_tuple patl -> List.iter f.f patl | Tpat_construct(_, _, patl, _) -> List.iter f.f patl | Tpat_variant(_, pat, _) -> Option.iter f.f pat @@ -695,8 +742,8 @@ type pattern_transformation = let shallow_map_pattern_desc : type k . pattern_transformation -> k pattern_desc -> k pattern_desc = fun f d -> match d with - | Tpat_alias (p1, id, s) -> - Tpat_alias (f.f p1, id, s) + | Tpat_alias (p1, id, s, uid) -> + Tpat_alias (f.f p1, id, s, uid) | Tpat_tuple pats -> Tpat_tuple (List.map f.f pats) | Tpat_record (lpats, closed) -> @@ -757,11 +804,11 @@ let rec iter_bound_idents : type k . _ -> k general_pattern -> _ = fun f pat -> match pat.pat_desc with - | Tpat_var (id,s) -> - f (id,s,pat.pat_type) - | Tpat_alias(p, id, s) -> + | Tpat_var (id, s, uid) -> + f (id,s,pat.pat_type, uid) + | Tpat_alias(p, id, s, uid) -> iter_bound_idents f p; - f (id,s,pat.pat_type) + f (id,s,pat.pat_type, uid) | Tpat_or(p1, _, _) -> (* Invariant : both arguments bind the same variables *) iter_bound_idents f p1 @@ -777,7 +824,7 @@ let rev_pat_bound_idents_full pat = !idents_full let rev_only_idents idents_full = - List.rev_map (fun (id,_,_) -> id) idents_full + List.rev_map (fun (id,_,_,_) -> id) idents_full let pat_bound_idents_full pat = List.rev (rev_pat_bound_idents_full pat) @@ -801,14 +848,14 @@ let alpha_var env id = List.assoc id env let rec alpha_pat : type k . _ -> k general_pattern -> k general_pattern = fun env p -> match p.pat_desc with - | Tpat_var (id, s) -> (* note the ``Not_found'' case *) + | Tpat_var (id, s, uid) -> (* note the ``Not_found'' case *) {p with pat_desc = - try Tpat_var (alpha_var env id, s) with + try Tpat_var (alpha_var env id, s, uid) with | Not_found -> Tpat_any} - | Tpat_alias (p1, id, s) -> + | Tpat_alias (p1, id, s, uid) -> let new_p : k general_pattern = alpha_pat env p1 in begin try - {p with pat_desc = Tpat_alias (new_p, alpha_var env id, s)} + {p with pat_desc = Tpat_alias (new_p, alpha_var env id, s, uid)} with | Not_found -> new_p end @@ -850,6 +897,22 @@ let split_pattern pat = in split_pattern pat +(* Expressions are considered nominal if they can be used as the subject of a + sentence or action. In practice, we consider that an expression is nominal + if they satisfy one of: + - Similar to an identifier: words separated by '.' or '#'. + - Do not contain spaces when printed. + *) +let rec exp_is_nominal exp = + match exp.exp_desc with + | _ when exp.exp_attributes <> [] -> false + | Texp_ident _ | Texp_instvar _ | Texp_constant _ + | Texp_variant (_, None) + | Texp_construct (_, _, []) -> + true + | Texp_field (parent, _, _) | Texp_send (parent, _) -> exp_is_nominal parent + | _ -> false + (* Merlin specific *) let unpack_functor_me me = diff --git a/src/ocaml/typing/typedtree.mli b/src/ocaml/typing/typedtree.mli index fffc5186e4..be0732c8ca 100644 --- a/src/ocaml/typing/typedtree.mli +++ b/src/ocaml/typing/typedtree.mli @@ -22,6 +22,7 @@ *) open Asttypes +module Uid = Shape.Uid (* Value expressions for the core language *) @@ -69,16 +70,18 @@ and pat_extra = | Tpat_unpack (** (module P) { pat_desc = Tpat_var "P" ; pat_extra = (Tpat_unpack, _, _) :: ... } + (module _) { pat_desc = Tpat_any + ; pat_extra = (Tpat_unpack, _, _) :: ... } *) and 'k pattern_desc = (* value patterns *) | Tpat_any : value pattern_desc (** _ *) - | Tpat_var : Ident.t * string loc -> value pattern_desc + | Tpat_var : Ident.t * string loc * Uid.t -> value pattern_desc (** x *) | Tpat_alias : - value general_pattern * Ident.t * string loc -> value pattern_desc + value general_pattern * Ident.t * string loc * Uid.t -> value pattern_desc (** P as a *) | Tpat_constant : constant -> value pattern_desc (** 1, 'a', "true", 1.0, 1l, 1L, 1n *) @@ -169,7 +172,7 @@ and exp_extra = (** Used for method bodies. *) | Texp_newtype of string (** fun (type t) -> *) - | Texp_newtype' of Ident.t * label loc + | Texp_newtype' of Ident.t * label loc * Uid.t (** merlin-specific: keep enough information to correctly implement occurrences for local-types. Merlin typechecker uses [Texp_newtype'] constructor, while upstream @@ -187,18 +190,17 @@ and expression_desc = (** let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive) let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive) *) - | Texp_function of { arg_label : arg_label; param : Ident.t; - cases : value case list; partial : partial; } - (** [Pexp_fun] and [Pexp_function] both translate to [Texp_function]. - See {!Parsetree} for more details. - - [param] is the identifier that is to be used to name the - parameter of the function. - - partial = - [Partial] if the pattern match is partial - [Total] otherwise. - *) + | Texp_function of function_param list * function_body + (** fun P0 P1 -> function p1 -> e1 | p2 -> e2 (body = Tfunction_cases _) + fun P0 P1 -> E (body = Tfunction_body _) + + This construct has the same arity as the originating + {{!Parsetree.expression_desc.Pexp_function}[Pexp_function]}. + Arity determines when side-effects for effectful parameters are run + (e.g. optional argument defaults, matching against lazy patterns). + Parameters' effects are run left-to-right when an n-ary function is + saturated with n arguments. + *) | Texp_apply of expression * (arg_label * expression option) list (** E0 ~l1:E1 ... ~ln:En @@ -270,7 +272,7 @@ and expression_desc = Ident.t option * string option loc * Types.module_presence * module_expr * expression | Texp_letexception of extension_constructor * expression - | Texp_assert of expression + | Texp_assert of expression * Location.t | Texp_lazy of expression | Texp_object of class_structure * string list | Texp_pack of module_expr @@ -299,8 +301,56 @@ and 'k case = c_rhs: expression; } +and function_param = + { + fp_arg_label: arg_label; + fp_param: Ident.t; + (** [fp_param] is the identifier that is to be used to name the + parameter of the function. + *) + fp_partial: partial; + (** + [fp_partial] = + [Partial] if the pattern match is partial + [Total] otherwise. + *) + fp_kind: function_param_kind; + fp_newtypes: string loc list; + (** [fp_newtypes] are the new type declarations that come *after* that + parameter. The newtypes that come before the first parameter are + placed as exp_extras on the Texp_function node. This is just used in + {!Untypeast}. *) + fp_loc: Location.t; + (** [fp_loc] is the location of the entire value parameter, not including + the [fp_newtypes]. + *) + } + +and function_param_kind = + | Tparam_pat of pattern + (** [Tparam_pat p] is a non-optional argument with pattern [p]. *) + | Tparam_optional_default of pattern * expression + (** [Tparam_optional_default (p, e)] is an optional argument [p] with default + value [e], i.e. [?x:(p = e)]. If the parameter is of type [a option], the + pattern and expression are of type [a]. *) + +and function_body = + | Tfunction_body of expression + | Tfunction_cases of + { cases: value case list; + partial: partial; + param: Ident.t; + loc: Location.t; + exp_extra: exp_extra option; + attributes: attributes; + (** [attributes] is just used in untypeast. *) + } +(** The function body binds a final argument in [Tfunction_cases], + and this argument is pattern-matched against the cases. +*) + and record_label_definition = - | Kept of Types.type_expr + | Kept of Types.type_expr * mutable_flag | Overridden of Longident.t loc * expression and binding_op = @@ -397,6 +447,7 @@ and module_expr_desc = | Tmod_structure of structure | Tmod_functor of functor_parameter * module_expr | Tmod_apply of module_expr * module_expr * module_coercion + | Tmod_apply_unit of module_expr | Tmod_constraint of module_expr * Types.module_type * module_type_constraint * module_coercion (** ME (constraint = Tmodtype_implicit) @@ -435,8 +486,9 @@ and structure_item_desc = and module_binding = { - mb_id: Ident.t option; + mb_id: Ident.t option; (** [None] for [module _ = struct ... end] *) mb_name: string option loc; + mb_uid: Uid.t; mb_presence: Types.module_presence; mb_expr: module_expr; mb_attributes: attributes; @@ -447,6 +499,7 @@ and value_binding = { vb_pat: pattern; vb_expr: expression; + vb_rec_kind: Value_rec_types.recursive_binding_kind; vb_attributes: attributes; vb_loc: Location.t; } @@ -457,7 +510,19 @@ and module_coercion = (Ident.t * int * module_coercion) list | Tcoerce_functor of module_coercion * module_coercion | Tcoerce_primitive of primitive_coercion + (** External declaration coerced to a regular value. + {[ + module M : sig val ext : a -> b end = + struct external ext : a -> b = "my_c_function" end + ]} + Only occurs inside a [Tcoerce_structure] coercion. *) | Tcoerce_alias of Env.t * Path.t * module_coercion + (** Module alias coerced to a regular module. + {[ + module M : sig module Sub : T end = + struct module Sub = Some_alias end + ]} + Only occurs inside a [Tcoerce_structure] coercion. *) and module_type = { mty_desc: module_type_desc; @@ -515,6 +580,7 @@ and module_declaration = { md_id: Ident.t option; md_name: string option loc; + md_uid: Uid.t; md_presence: Types.module_presence; md_type: module_type; md_attributes: attributes; @@ -525,6 +591,7 @@ and module_substitution = { ms_id: Ident.t; ms_name: string loc; + ms_uid: Uid.t; ms_manifest: Path.t; ms_txt: Longident.t loc; ms_attributes: attributes; @@ -535,6 +602,7 @@ and module_type_declaration = { mtd_id: Ident.t; mtd_name: string loc; + mtd_uid: Uid.t; mtd_type: module_type option; mtd_attributes: attributes; mtd_loc: Location.t; @@ -593,10 +661,11 @@ and core_type_desc = | Ttyp_constr of Path.t * Longident.t loc * core_type list | Ttyp_object of object_field list * closed_flag | Ttyp_class of Path.t * Longident.t loc * core_type list - | Ttyp_alias of core_type * string + | Ttyp_alias of core_type * string loc | Ttyp_variant of row_field list * closed_flag * label list option | Ttyp_poly of string list * core_type | Ttyp_package of package_type + | Ttyp_open of Path.t * Longident.t loc * core_type and package_type = { pack_path : Path.t; @@ -659,6 +728,7 @@ and label_declaration = { ld_id: Ident.t; ld_name: string loc; + ld_uid: Uid.t; ld_mutable: mutable_flag; ld_type: core_type; ld_loc: Location.t; @@ -669,6 +739,7 @@ and constructor_declaration = { cd_id: Ident.t; cd_name: string loc; + cd_uid: Uid.t; cd_vars: string loc list; cd_args: constructor_arguments; cd_res: core_type option; @@ -762,7 +833,6 @@ and 'a class_infos = ci_id_class: Ident.t; ci_id_class_type : Ident.t; ci_id_object : Ident.t; - ci_id_typehash : Ident.t; ci_expr: 'a; ci_decl: Types.class_declaration; ci_type_decl : Types.class_type_declaration; @@ -786,6 +856,23 @@ type implementation = { structure. *) +type item_declaration = + | Value of value_description + | Value_binding of value_binding + | Type of type_declaration + | Constructor of constructor_declaration + | Extension_constructor of extension_constructor + | Label of label_declaration + | Module of module_declaration + | Module_substitution of module_substitution + | Module_binding of module_binding + | Module_type of module_type_declaration + | Class of class_declaration + | Class_type of class_type_declaration +(** [item_declaration] groups together items that correspond to the syntactic + category of "declarations" which include types, values, modules, etc. + declarations in signatures and their definitions in implementations. *) + (* Auxiliary functions over the a.s.t. *) (** [as_computation_pattern p] is a computation pattern with description @@ -816,7 +903,8 @@ val exists_pattern: (pattern -> bool) -> pattern -> bool val let_bound_idents: value_binding list -> Ident.t list val let_bound_idents_full: - value_binding list -> (Ident.t * string loc * Types.type_expr) list + value_binding list -> + (Ident.t * string loc * Types.type_expr * Types.Uid.t) list (** Alpha conversion of patterns *) val alpha_pat: @@ -827,12 +915,17 @@ val mkloc: 'a -> Location.t -> 'a Asttypes.loc val pat_bound_idents: 'k general_pattern -> Ident.t list val pat_bound_idents_full: - 'k general_pattern -> (Ident.t * string loc * Types.type_expr) list + 'k general_pattern -> + (Ident.t * string loc * Types.type_expr * Types.Uid.t) list (** Splits an or pattern into its value (left) and exception (right) parts. *) val split_pattern: computation general_pattern -> pattern option * pattern option +(** Whether an expression looks nice as the subject of a sentence in a error + message. *) +val exp_is_nominal : expression -> bool + (* Merlin specific *) val unpack_functor_me : module_expr -> functor_parameter * module_expr diff --git a/src/ocaml/typing/typemod.ml b/src/ocaml/typing/typemod.ml index 7020d7d3c1..a5fea9214b 100644 --- a/src/ocaml/typing/typemod.ml +++ b/src/ocaml/typing/typemod.ml @@ -21,6 +21,8 @@ open Parsetree open Types open Format +module Style = Misc.Style + let () = Includemod_errorprinter.register () module Sig_component_kind = Shape.Sig_component_kind @@ -56,9 +58,11 @@ type error = Longident.t * Path.t * Includemod.explanation | With_changes_module_alias of Longident.t * Ident.t * Path.t | With_cannot_remove_constrained_type + | With_package_manifest of Longident.t * type_expr | Repeated_name of Sig_component_kind.t * string - | Non_generalizable of type_expr - | Non_generalizable_module of module_type + | Non_generalizable of { vars : type_expr list; expression : type_expr } + | Non_generalizable_module of + { vars : type_expr list; item : value_description; mty : module_type } | Implementation_is_required of string | Interface_not_compiled of string | Not_allowed_in_functor_body @@ -85,6 +89,7 @@ let rec path_concat head p = Pident tail -> Pdot (Pident head, Ident.name tail) | Pdot (pre, s) -> Pdot (path_concat head pre, s) | Papply _ -> assert false + | Pextra_ty (p, extra) -> Pextra_ty (path_concat head p, extra) (* Extract a signature from a module type *) @@ -115,14 +120,9 @@ let type_open_ ?used_slot ?toplevel ovf env loc lid = ignore (extract_sig_open env lid.loc md.md_type); assert false -let initial_env ~loc ~safe_string ~initially_opened_module +let initial_env ~loc ~initially_opened_module ~open_implicit_modules = - let env = - if safe_string then - Env.initial_safe_string - else - Env.initial_unsafe_string - in + let env = Env.initial in let open_module env m = let open Asttypes in let lid = {loc; txt = Longident.parse m } in @@ -146,7 +146,7 @@ let initial_env ~loc ~safe_string ~initially_opened_module env in let units = - List.map Env.persistent_structures_of_dir (Load_path.get ()) + List.map Env.persistent_structures_of_dir (Load_path.get_visible ()) in let env, units = match initially_opened_module with @@ -245,7 +245,7 @@ let check_type_decl env sg loc id row_id newdecl decl = let make_variance p n i = let open Variance in - set May_pos p (set May_neg n (set May_weak n (set Inj i null))) + set_if p May_pos (set_if n May_neg (set_if i Inj null)) let rec iter_path_apply p ~f = match p with @@ -255,6 +255,7 @@ let rec iter_path_apply p ~f = iter_path_apply p1 ~f; iter_path_apply p2 ~f; f p1 p2 (* after recursing, so we know both paths are well typed *) + | Pextra_ty _ -> assert false let path_is_strict_prefix = let rec list_is_strict_prefix l ~prefix = @@ -452,7 +453,6 @@ let type_decl_is_alias sdecl = (* assuming no explicit constraint *) | () -> Some lid end | _ -> None -;; let params_are_constrained = let rec loop = function @@ -463,7 +463,6 @@ let params_are_constrained = | _ -> true in loop -;; type with_info = | With_type of Parsetree.type_declaration @@ -477,11 +476,15 @@ type with_info = | With_modsubst of Longident.t loc * Path.t * Types.module_declaration | With_modtype of Typedtree.module_type | With_modtypesubst of Typedtree.module_type + | With_type_package of Typedtree.core_type + (* Package with type constraints only use this last case. Normal module + with constraints never use it. *) let merge_constraint initial_env loc sg lid constr = let destructive_substitution = match constr with - | With_type _ | With_module _ | With_modtype _ -> false + | With_type _ | With_module _ | With_modtype _ + | With_type_package _ -> false | With_typesubst _ | With_modsubst _ | With_modtypesubst _ -> true in let real_ids = ref [] in @@ -510,7 +513,7 @@ let merge_constraint initial_env loc sg lid constr = type_params = List.map (fun _ -> Btype.newgenvar()) sdecl.ptype_params; type_arity = arity; - type_kind = Type_abstract; + type_kind = Type_abstract Definition; type_private = Private; type_manifest = None; type_variance = @@ -555,7 +558,7 @@ let merge_constraint initial_env loc sg lid constr = in return ~ghosts ~replace_by:(Some (Sig_type(id, newdecl, rs, priv))) - (Pident id, lid, Twith_type tdecl) + (Pident id, lid, Some (Twith_type tdecl)) | Sig_type(id, sig_decl, rs, priv) , [s], (With_type sdecl | With_typesubst sdecl as constr) when Ident.name id = s -> @@ -572,12 +575,26 @@ let merge_constraint initial_env loc sg lid constr = With_type _ -> return ~ghosts ~replace_by:(Some(Sig_type(id, newdecl, rs, priv))) - (Pident id, lid, Twith_type tdecl) + (Pident id, lid, Some (Twith_type tdecl)) | (* With_typesubst *) _ -> real_ids := [Pident id]; return ~ghosts ~replace_by:None - (Pident id, lid, Twith_typesubst tdecl) + (Pident id, lid, Some (Twith_typesubst tdecl)) end + | Sig_type(id, sig_decl, rs, priv), [s], With_type_package cty + when Ident.name id = s -> + begin match sig_decl.type_manifest with + | None -> () + | Some ty -> + raise (Error(loc, outer_sig_env, With_package_manifest (lid.txt, ty))) + end; + let tdecl = + Typedecl.transl_package_constraint ~loc outer_sig_env cty.ctyp_type + in + check_type_decl outer_sig_env sg_for_env loc id None tdecl sig_decl; + let tdecl = { tdecl with type_manifest = None } in + return ~ghosts ~replace_by:(Some(Sig_type(id, tdecl, rs, priv))) + (Pident id, lid, None) | Sig_modtype(id, mtd, priv), [s], (With_modtype mty | With_modtypesubst mty) when Ident.name id = s -> @@ -599,7 +616,7 @@ let merge_constraint initial_env loc sg lid constr = in return ~replace_by:(Some(Sig_modtype(id, mtd', priv))) - (Pident id, lid, Twith_modtype mty) + (Pident id, lid, Some (Twith_modtype mty)) else begin let path = Pident id in real_ids := [path]; @@ -607,7 +624,8 @@ let merge_constraint initial_env loc sg lid constr = | Mty_ident _ -> () | mty -> unpackable_modtype := Some mty end; - return ~replace_by:None (Pident id, lid, Twith_modtypesubst mty) + return ~replace_by:None + (Pident id, lid, Some (Twith_modtypesubst mty)) end | Sig_module(id, pres, md, rs, priv), [s], With_module {lid=lid'; md=md'; path; remove_aliases} @@ -621,7 +639,7 @@ let merge_constraint initial_env loc sg lid constr = newmd.md_type md.md_type); return ~replace_by:(Some(Sig_module(id, pres, newmd, rs, priv))) - (Pident id, lid, Twith_module (path, lid')) + (Pident id, lid, Some (Twith_module (path, lid'))) | Sig_module(id, _, md, _rs, _), [s], With_modsubst (lid',path,md') when Ident.name id = s -> let sig_env = Env.add_signature sg_for_env outer_sig_env in @@ -630,7 +648,8 @@ let merge_constraint initial_env loc sg lid constr = (Includemod.strengthened_module_decl ~loc ~mark:Mark_both ~aliasable sig_env md' path md); real_ids := [Pident id]; - return ~replace_by:None (Pident id, lid, Twith_modsubst (path, lid')) + return ~replace_by:None + (Pident id, lid, Some (Twith_modsubst (path, lid'))) | Sig_module(id, _, md, rs, priv) as item, s :: namelist, constr when Ident.name id = s -> let sig_env = Env.add_signature sg_for_env outer_sig_env in @@ -665,7 +684,7 @@ let merge_constraint initial_env loc sg lid constr = !unpackable_modtype sg; let sg = match tcstr with - | (_, _, Twith_typesubst tdecl) -> + | (_, _, Some (Twith_typesubst tdecl)) -> let how_to_extend_subst = let sdecl = match constr with @@ -694,7 +713,7 @@ let merge_constraint initial_env loc sg lid constr = making it local makes it unlikely that we will ever use the result of this function unfreshened without issue. *) Subst.signature Make_local sub sg - | (_, _, Twith_modsubst (real_path, _)) -> + | (_, _, Some (Twith_modsubst (real_path, _))) -> let sub = Subst.change_locs Subst.identity loc in let sub = List.fold_left @@ -704,7 +723,7 @@ let merge_constraint initial_env loc sg lid constr = in (* See explanation in the [Twith_typesubst] case above. *) Subst.signature Make_local sub sg - | (_, _, Twith_modtypesubst tmty) -> + | (_, _, Some (Twith_modtypesubst tmty)) -> let add s p = Subst.add_modtype_path p tmty.mty_type s in let sub = Subst.change_locs Subst.identity loc in let sub = List.fold_left add sub !real_ids in @@ -718,6 +737,25 @@ let merge_constraint initial_env loc sg lid constr = with Includemod.Error explanation -> raise(Error(loc, initial_env, With_mismatch(lid.txt, explanation))) +let merge_package_constraint initial_env loc sg lid cty = + let _, s = merge_constraint initial_env loc sg lid (With_type_package cty) in + s + +let check_package_with_type_constraints loc env mty constraints = + let sg = extract_sig env loc mty in + let sg = + List.fold_left + (fun sg (lid, cty) -> + merge_package_constraint env loc sg lid cty) + sg constraints + in + let scope = Ctype.create_scope () in + Mtype.freshen ~scope (Mty_signature sg) + +let () = + Typetexp.check_package_with_type_constraints := + check_package_with_type_constraints + (* Add recursion flags on declarations arising from a mutually recursive block. *) @@ -912,14 +950,13 @@ and approx_sig env ssg = (extract_sig env smty.pmty_loc mty) env in sg @ approx_sig newenv srem | Psig_class sdecls | Psig_class_type sdecls -> - let decls = Typeclass.approx_class_declarations env sdecls in + let decls, env = Typeclass.approx_class_declarations env sdecls in let rem = approx_sig env srem in map_rec (fun rs decl -> let open Typeclass in [ Sig_class_type(decl.clsty_ty_id, decl.clsty_ty_decl, rs, Exported); Sig_type(decl.clsty_obj_id, decl.clsty_obj_abbr, rs, Exported); - Sig_type(decl.clsty_typesharp_id, decl.clsty_abbr, rs, Exported); ] ) decls [rem] |> List.flatten @@ -1051,7 +1088,7 @@ end = struct let open Sig_component_kind in match component with | Value -> names.values - | Type -> names.types + | Type | Label | Constructor -> names.types | Module -> names.modules | Module_type -> names.modtypes | Extension_constructor -> names.typexts @@ -1248,8 +1285,7 @@ end let has_remove_aliases_attribute attr = let remove_aliases = - Attr_helper.get_no_payload_attribute - ["remove_aliases"; "ocaml.remove_aliases"] attr + Attr_helper.get_no_payload_attribute "remove_aliases" attr in match remove_aliases with | None -> false @@ -1369,12 +1405,14 @@ and transl_with ~loc env remove_aliases (rev_tcstrs,sg) constr = let mty = transl_modtype env smty in l, With_modtypesubst mty in - let (tcstr, sg) = merge_constraint env loc sg lid with_info in - (tcstr :: rev_tcstrs, sg) + let ((path, lid, tcstr), sg) = merge_constraint env loc sg lid with_info in + (* Only package with constraints result in None here. *) + let tcstr = Option.get tcstr in + ((path, lid, tcstr) :: rev_tcstrs, sg) -and transl_signature ?(keep_warnings = false) env sg = +and transl_signature ?(keep_warnings = false) ?(toplevel = false) env sg = let names = Signature_names.create () in let rec transl_sig env sg = match sg with @@ -1388,7 +1426,6 @@ and transl_signature ?(keep_warnings = false) env sg = Typedecl.transl_value_decl env item.psig_loc sdesc in Signature_names.check_value names tdesc.val_loc tdesc.val_id; - Env.register_uid tdesc.val_val.val_uid tdesc.val_loc; res with | (tdesc, newenv) -> @@ -1402,17 +1439,15 @@ and transl_signature ?(keep_warnings = false) env sg = end | Psig_type (rec_flag, sdecls) -> begin match - let (decls, _) as res = + let (decls, _, _) as res = Typedecl.transl_type_decl env rec_flag sdecls in List.iter (fun td -> Signature_names.check_type names td.typ_loc td.typ_id; - if not (Btype.is_row_name (Ident.name td.typ_id)) then - Env.register_uid td.typ_type.type_uid td.typ_loc ) decls; res with - | (decls, newenv) -> + | (decls, newenv, _) -> let newenv = Env.update_short_paths newenv in let (trem, rem, final_env) = transl_sig newenv srem in let sg = @@ -1437,7 +1472,7 @@ and transl_signature ?(keep_warnings = false) env sg = once we have nice error messages there. *) raise (Error (td.ptype_loc, env, Invalid_type_subst_rhs)) ) sdecls; - let (decls, _) as res = + let (decls, _, _) as res = Typedecl.transl_type_decl env Nonrecursive sdecls in List.iter (fun td -> @@ -1453,12 +1488,11 @@ and transl_signature ?(keep_warnings = false) env sg = in Some (`Substituted_away subst) in - Signature_names.check_type ?info names td.typ_loc td.typ_id; - Env.register_uid td.typ_type.type_uid td.typ_loc + Signature_names.check_type ?info names td.typ_loc td.typ_id ) decls; res with - | (decls, newenv) -> + | (decls, newenv, _) -> let (trem, rem, final_env) = transl_sig newenv srem in let sg = rem in @@ -1471,17 +1505,16 @@ and transl_signature ?(keep_warnings = false) env sg = end | Psig_typext styext -> begin match - let (tyext, _) as res = + let (tyext, _, _) as res = Typedecl.transl_type_extension false env item.psig_loc styext in let constructors = tyext.tyext_constructors in List.iter (fun ext -> - Signature_names.check_typext names ext.ext_loc ext.ext_id; - Env.register_uid ext.ext_type.ext_uid ext.ext_loc + Signature_names.check_typext names ext.ext_loc ext.ext_id ) constructors; res, constructors with - | (tyext, newenv), constructors -> + | (tyext, newenv, _shapes), constructors -> let (trem, rem, final_env) = transl_sig newenv srem in mksig (Tsig_typext tyext) env loc :: trem, map_ext (fun es ext -> @@ -1494,16 +1527,13 @@ and transl_signature ?(keep_warnings = false) env sg = end | Psig_exception sext -> begin match - let (ext, _) as res = Typedecl.transl_type_exception env sext in + let (ext, _, _) as res = Typedecl.transl_type_exception env sext in let constructor = ext.tyexn_constructor in Signature_names.check_typext names constructor.ext_loc constructor.ext_id; - Env.register_uid - constructor.ext_type.ext_uid - constructor.ext_loc; res, constructor with - | (ext, newenv), constructor -> + | (ext, newenv, _shape), constructor -> let (trem, rem, final_env) = transl_sig newenv srem in mksig (Tsig_exception ext) env loc :: trem, Sig_typext(constructor.ext_id, @@ -1527,30 +1557,29 @@ and transl_signature ?(keep_warnings = false) env sg = | Mty_alias _ -> Mp_absent | _ -> Mp_present in + let md = { + md_type=tmty.mty_type; + md_attributes=pmd.pmd_attributes; + md_loc=pmd.pmd_loc; + md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); + } + in match pmd.pmd_name.txt with - | None -> None, pres, env, None, tmty + | None -> None, pres, env, None, tmty, md | Some name -> - let md = { - md_type=tmty.mty_type; - md_attributes=pmd.pmd_attributes; - md_loc=pmd.pmd_loc; - md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); - } - in let id, newenv = Env.enter_module_declaration ~scope name pres md env in let newenv = Env.update_short_paths newenv in Signature_names.check_module names pmd.pmd_name.loc id; - Env.register_uid md.md_uid md.md_loc; let sig_item = Sig_module(id, pres, md, Trec_not, Exported) in - Some id, pres, newenv, Some sig_item, tmty + Some id, pres, newenv, Some sig_item, tmty, md with - | (id, pres, newenv, sig_item, tmty) -> + | (id, pres, newenv, sig_item, tmty, md) -> let (trem, rem, final_env) = transl_sig newenv srem in mksig (Tsig_module {md_id=id; md_name=pmd.pmd_name; - md_presence=pres; md_type=tmty; - md_loc=pmd.pmd_loc; + md_uid=md.md_uid; md_presence=pres; + md_type=tmty; md_loc=pmd.pmd_loc; md_attributes=pmd.pmd_attributes}) env loc :: trem, (match sig_item with None -> rem | Some i -> i :: rem), @@ -1589,10 +1618,9 @@ and transl_signature ?(keep_warnings = false) env sg = `Substituted_away (Subst.add_module id path Subst.identity) in Signature_names.check_module ~info names pms.pms_name.loc id; - Env.register_uid md.md_uid md.md_loc; (newenv, Tsig_modsubst {ms_id=id; ms_name=pms.pms_name; - ms_manifest=path; ms_txt=pms.pms_manifest; - ms_loc=pms.pms_loc; + ms_uid=md.md_uid; ms_manifest=path; + ms_txt=pms.pms_manifest; ms_loc=pms.pms_loc; ms_attributes=pms.pms_attributes}) with | newenv, sig_item -> @@ -1613,9 +1641,8 @@ and transl_signature ?(keep_warnings = false) env sg = | Some id -> Some (id, md, uid) ) tdecls in - List.iter (fun (id, md, uid) -> + List.iter (fun (id, md, _uid) -> Signature_names.check_module names md.md_loc id; - Env.register_uid uid md.md_loc ) decls; (tdecls, decls, newenv) with @@ -1640,7 +1667,6 @@ and transl_signature ?(keep_warnings = false) env sg = begin match transl_modtype_decl env pmtd with | newenv, mtd, decl -> Signature_names.check_modtype names pmtd.pmtd_loc mtd.mtd_id; - Env.register_uid decl.mtd_uid mtd.mtd_loc; let (trem, rem, final_env) = transl_sig newenv srem in mksig (Tsig_modtype mtd) env loc :: trem, Sig_modtype (mtd.mtd_id, decl, Exported) :: rem, @@ -1651,7 +1677,7 @@ and transl_signature ?(keep_warnings = false) env sg = end | Psig_modtypesubst pmtd -> begin match transl_modtype_decl env pmtd with - | newenv, mtd, decl -> + | newenv, mtd, _decl -> let info = let mty = match mtd.mtd_type with | Some tmty -> tmty.mty_type @@ -1665,7 +1691,6 @@ and transl_signature ?(keep_warnings = false) env sg = | _ -> `Unpackable_modtype_substituted_away (mtd.mtd_id,subst) in Signature_names.check_modtype ~info names pmtd.pmtd_loc mtd.mtd_id; - Env.register_uid decl.mtd_uid mtd.mtd_loc; let (trem, rem, final_env) = transl_sig newenv srem in mksig (Tsig_modtypesubst mtd) env loc :: trem, rem, @@ -1725,8 +1750,6 @@ and transl_signature ?(keep_warnings = false) env sg = Signature_names.check_type names loc cls.cls_obj_id; Signature_names.check_class names loc cls.cls_id; Signature_names.check_class_type names loc cls.cls_ty_id; - Signature_names.check_type names loc cls.cls_typesharp_id; - Env.register_uid cls.cls_decl.cty_uid cls.cls_decl.cty_loc; ) classes; res with @@ -1737,8 +1760,8 @@ and transl_signature ?(keep_warnings = false) env sg = let open Typeclass in [Sig_class(cls.cls_id, cls.cls_decl, rs, Exported); Sig_class_type(cls.cls_ty_id, cls.cls_ty_decl, rs, Exported); - Sig_type(cls.cls_obj_id, cls.cls_obj_abbr, rs, Exported); - Sig_type(cls.cls_typesharp_id, cls.cls_abbr, rs, Exported)] + Sig_type(cls.cls_obj_id, cls.cls_obj_abbr, rs, Exported) + ] ) classes [rem] |> List.flatten in @@ -1761,10 +1784,6 @@ and transl_signature ?(keep_warnings = false) env sg = let loc = decl.clsty_id_loc.Location.loc in Signature_names.check_class_type names loc decl.clsty_ty_id; Signature_names.check_type names loc decl.clsty_obj_id; - Signature_names.check_type names loc decl.clsty_typesharp_id; - Env.register_uid - decl.clsty_ty_decl.clty_uid - decl.clsty_ty_decl.clty_loc; ) classes; res with @@ -1776,8 +1795,6 @@ and transl_signature ?(keep_warnings = false) env sg = [Sig_class_type(decl.clsty_ty_id, decl.clsty_ty_decl, rs, Exported); Sig_type(decl.clsty_obj_id, decl.clsty_obj_abbr, rs, Exported); - Sig_type(decl.clsty_typesharp_id, decl.clsty_abbr, rs, - Exported) ] ) classes [rem] |> List.flatten @@ -1796,6 +1813,8 @@ and transl_signature ?(keep_warnings = false) env sg = end | Psig_attribute x -> Builtin_attributes.warning_attribute x; + if toplevel || not (Warnings.is_active (Misplaced_attribute "")) + then Builtin_attributes.mark_alert_used x; let (trem,rem, final_env) = transl_sig env srem in mksig (Tsig_attribute x) env loc :: trem, rem, final_env | Psig_extension (ext, _attrs) -> @@ -1834,6 +1853,7 @@ and transl_modtype_decl_aux env { mtd_id=id; mtd_name=pmtd_name; + mtd_uid=decl.mtd_uid; mtd_type=tmty; mtd_attributes=pmtd_attributes; mtd_loc=pmtd_loc; @@ -1916,11 +1936,11 @@ and transl_recmodule_modtypes env sdecls = List.map2 (fun pmd (id_shape, id_loc, md, mty) -> let tmd = {md_id=Option.map fst id_shape; md_name=id_loc; md_type=mty; - md_presence=Mp_present; + md_uid=md.Types.md_uid; md_presence=Mp_present; md_loc=pmd.pmd_loc; md_attributes=pmd.pmd_attributes} in - tmd, md.md_uid, Option.map snd id_shape + tmd, md.Types.md_uid, Option.map snd id_shape ) sdecls dcl2 in (dcl2, env2) @@ -1936,7 +1956,9 @@ let rec path_of_module mexp = Papply(path_of_module funct, path_of_module arg) | Tmod_constraint (mexp, _, _, _) -> path_of_module mexp - | _ -> raise Not_a_path + | (Tmod_structure _ | Tmod_functor _ | Tmod_apply_unit _ | Tmod_unpack _ | + Tmod_apply _ | Tmod_hole) -> + raise Not_a_path let path_of_module mexp = try Some (path_of_module mexp) with Not_a_path -> None @@ -1945,12 +1967,12 @@ let path_of_module mexp = do not contain non-generalized type variable *) let rec nongen_modtype env = function - Mty_ident _ -> false - | Mty_alias _ -> false - | Mty_for_hole -> false + Mty_ident _ -> None + | Mty_alias _ -> None + | Mty_for_hole -> None | Mty_signature sg -> let env = Env.add_signature sg env in - List.exists (nongen_signature_item env) sg + List.find_map (nongen_signature_item env) sg | Mty_functor(arg_opt, body) -> let env = match arg_opt with @@ -1962,18 +1984,35 @@ let rec nongen_modtype env = function nongen_modtype env body and nongen_signature_item env = function - Sig_value(_id, desc, _) -> Ctype.nongen_schema env desc.val_type + | Sig_value(_id, desc, _) -> + Ctype.nongen_vars_in_schema env desc.val_type + |> Option.map (fun vars -> (vars, desc)) | Sig_module(_id, _, md, _, _) -> nongen_modtype env md.md_type - | _ -> false + | _ -> None + +let check_nongen_modtype env loc mty = + nongen_modtype env mty + |> Option.iter (fun (vars, item) -> + let vars = Btype.TypeSet.elements vars in + let error = + Non_generalizable_module { vars; item; mty } + in + raise(Error(loc, env, error)) + ) let check_nongen_signature_item env sig_item = match sig_item with Sig_value(_id, vd, _) -> - if Ctype.nongen_schema env vd.val_type then - raise (Error (vd.val_loc, env, Non_generalizable vd.val_type)) + Ctype.nongen_vars_in_schema env vd.val_type + |> Option.iter (fun vars -> + let vars = Btype.TypeSet.elements vars in + let error = + Non_generalizable { vars; expression = vd.val_type } + in + raise (Error (vd.val_loc, env, error)) + ) | Sig_module (_id, _, md, _, _) -> - if nongen_modtype env md.md_type then - raise(Error(md.md_loc, env, Non_generalizable_module md.md_type)) + check_nongen_modtype env md.md_loc md.md_type | _ -> () let check_nongen_signature env sg = @@ -2110,6 +2149,7 @@ let check_recmodule_inclusion env bindings = { mb_id = id; mb_name = name; + mb_uid = uid; mb_presence = Mp_present; mb_expr = modl'; mb_attributes = attrs; @@ -2130,7 +2170,9 @@ let rec package_constraints_sig env loc sg constrs = | Sig_type (id, ({type_params=[]} as td), rs, priv) when List.mem_assoc [Ident.name id] constrs -> let ty = List.assoc [Ident.name id] constrs in - Sig_type (id, {td with type_manifest = Some ty}, rs, priv) + let td = {td with type_manifest = Some ty} in + let type_immediate = Typedecl_immediacy.compute_decl env td in + Sig_type (id, {td with type_immediate}, rs, priv) | Sig_module (id, pres, md, rs, priv) -> let rec aux = function | (m :: ((_ :: _) as l), t) :: rest when m = Ident.name id -> @@ -2184,7 +2226,7 @@ let package_subtype env p1 fl1 p2 fl2 = let () = Ctype.package_subtype := package_subtype -let wrap_constraint env mark arg mty explicit = +let wrap_constraint_package env mark arg mty explicit = let mark = if mark then Includemod.Mark_both else Includemod.Mark_neither in let mty1 = Subst.modtype Keep Subst.identity arg.mod_type in let mty2 = Subst.modtype Keep Subst.identity mty in @@ -2219,23 +2261,30 @@ let wrap_constraint_with_shape env mark arg mty (* Type a module value expression *) -(* Summary for F(X) *) +(* These describe the X in [F(X)] (which might be missing, for [F ()]) *) +type argument_summary = { + is_syntactic_unit: bool; + arg: Typedtree.module_expr; + path: Path.t option; + shape: Shape.t +} + type application_summary = { loc: Location.t; attributes: attributes; f_loc: Location.t; (* loc for F *) - arg_is_syntactic_unit: bool; - arg: Typedtree.module_expr; - arg_path: Path.t option; - shape: Shape.t + arg: argument_summary option (* None for () *) } -let simplify_app_summary app_view = - let mty = app_view.arg.mod_type in - match app_view.arg_is_syntactic_unit , app_view.arg_path with - | true, _ -> Includemod.Error.Unit, mty - | false, Some p -> Includemod.Error.Named p, mty - | false, None -> Includemod.Error.Anonymous, mty +let simplify_app_summary app_view = match app_view.arg with + | None -> + Includemod.Error.Unit, Mty_signature [] + | Some arg -> + let mty = arg.arg.mod_type in + match arg.is_syntactic_unit , arg.path with + | true , _ -> Includemod.Error.Empty_struct, mty + | false, Some p -> Includemod.Error.Named p, mty + | false, None -> Includemod.Error.Anonymous, mty let rec type_module ?(alias=false) sttn funct_body anchor env smod = (* Merlin: when we start typing a module we don't want to include potential @@ -2273,6 +2322,7 @@ and type_module_aux ~alias sttn funct_body anchor env smod = let shape = Env.shape_of_path ~namespace:Shape.Sig_component_kind.Module env path in + let shape = if alias && aliasable then Shape.alias shape else shape in let md = if alias && aliasable then (Env.add_required_global (Path.head path); md) @@ -2349,7 +2399,7 @@ and type_module_aux ~alias sttn funct_body anchor env smod = mod_attributes = smod.pmod_attributes; mod_loc = smod.pmod_loc }, Shape.abs funct_shape_param body_shape - | Pmod_apply _ -> + | Pmod_apply _ | Pmod_apply_unit _ -> type_application smod.pmod_loc sttn funct_body env smod | Pmod_constraint(sarg, smty) -> let arg, arg_shape = type_module ~alias true funct_body anchor env sarg in @@ -2381,12 +2431,11 @@ and type_module_aux ~alias sttn funct_body anchor env smod = | _ -> raise exn end | Pmod_unpack sexp -> - if !Clflags.principal then Ctype.begin_def (); - let exp = Typecore.type_exp env sexp in - if !Clflags.principal then begin - Ctype.end_def (); - Ctype.generalize_structure exp.exp_type - end; + let exp = + Ctype.with_local_level_if_principal + (fun () -> Typecore.type_exp env sexp) + ~post:Typecore.generalize_structure_exp + in let mty = match get_desc (Ctype.expand_head env exp.exp_type) with Tpackage (p, fl) -> @@ -2426,61 +2475,100 @@ and type_module_aux ~alias sttn funct_body anchor env smod = and type_application loc strengthen funct_body env smod = let rec extract_application funct_body env sargs smod = match smod.pmod_desc with - | Pmod_apply(f, sarg) -> + | Pmod_apply (f, sarg) -> let arg, shape = type_module true funct_body None env sarg in - let summary = - { loc=smod.pmod_loc; - attributes=smod.pmod_attributes; - f_loc = f.pmod_loc; - arg_is_syntactic_unit = sarg.pmod_desc = Pmod_structure []; + let summary = { + loc = smod.pmod_loc; + attributes = smod.pmod_attributes; + f_loc = f.pmod_loc; + arg = Some { + is_syntactic_unit = sarg.pmod_desc = Pmod_structure []; arg; - arg_path = path_of_module arg; - shape + path = path_of_module arg; + shape; } - in + } in + extract_application funct_body env (summary::sargs) f + | Pmod_apply_unit f -> + let summary = { + loc = smod.pmod_loc; + attributes = smod.pmod_attributes; + f_loc = f.pmod_loc; + arg = None + } in extract_application funct_body env (summary::sargs) f | _ -> smod, sargs in let sfunct, args = extract_application funct_body env [] smod in let funct, funct_shape = - let strengthen = - strengthen && List.for_all (fun {arg_path;_} -> arg_path <> None) args + let has_path { arg } = match arg with + | None | Some { path = None } -> false + | Some { path = Some _ } -> true in + let strengthen = strengthen && List.for_all has_path args in type_module strengthen funct_body None env sfunct in - List.fold_left (type_one_application ~ctx:(loc, funct, args) funct_body env) + List.fold_left + (type_one_application ~ctx:(loc, sfunct, funct, args) funct_body env) (funct, funct_shape) args -and type_one_application ~ctx:(apply_loc,md_f,args) - funct_body env (funct, funct_shape) app_view = +and type_one_application ~ctx:(apply_loc,sfunct,md_f,args) + funct_body env (funct, funct_shape) app_view = match Env.scrape_alias env funct.mod_type with | Mty_functor (Unit, mty_res) -> - if not app_view.arg_is_syntactic_unit then - raise (Error (app_view.f_loc, env, Apply_generative)); + begin match app_view.arg with + | None -> () + | Some arg -> + if arg.is_syntactic_unit then + (* this call to warning_scope allows e.g. + [ F (struct end [@warning "-73"]) ] + not to warn; useful when generating code that must + work over multiple versions of OCaml *) + Builtin_attributes.warning_scope arg.arg.mod_attributes @@ fun () -> + Location.prerr_warning arg.arg.mod_loc + Warnings.Generative_application_expects_unit + else + raise (Error (app_view.f_loc, env, Apply_generative)); + end; if funct_body && Mtype.contains_type env funct.mod_type then - raise (Error (apply_loc, env, Not_allowed_in_functor_body)); - { mod_desc = Tmod_apply(funct, app_view.arg, Tcoerce_none); + Msupport.raise_error + (Error (apply_loc, env, Not_allowed_in_functor_body)); + { mod_desc = Tmod_apply_unit funct; mod_type = mty_res; mod_env = env; mod_attributes = app_view.attributes; mod_loc = funct.mod_loc }, - Shape.app funct_shape ~arg:app_view.shape + Shape.app funct_shape ~arg:Shape.dummy_mod | Mty_functor (Named (param, mty_param), mty_res) as mty_functor -> + let apply_error () = + let args = List.map simplify_app_summary args in + let mty_f = md_f.mod_type in + let app_name = match sfunct.pmod_desc with + | Pmod_ident l -> Includemod.Named_leftmost_functor l.txt + | _ -> Includemod.Anonymous_functor + in + Includemod.Apply_error {loc=apply_loc;env;app_name;mty_f;args} + in + begin match app_view with + | { arg = None; loc = app_loc; attributes = app_attributes; _ } -> + Msupport.raise_error (apply_error ()); + { mod_desc = Tmod_apply_unit(funct); + mod_type = mty_res; + mod_env = env; + mod_attributes = app_attributes; + mod_loc = app_loc }, + funct_shape + | { loc = app_loc; attributes = app_attributes; + arg = Some { shape = arg_shape; path = arg_path; arg } } -> let coercion = - try - Includemod.modtypes - ~loc:app_view.arg.mod_loc ~mark:Mark_both env - app_view.arg.mod_type mty_param - with Includemod.Error msg -> - let _args = List.map simplify_app_summary args in - let _mty_f = md_f.mod_type in - let _lid_app = None in - Msupport.raise_error( - Error(app_view.arg.mod_loc, env, Not_included msg)); + try Includemod.modtypes + ~loc:arg.mod_loc ~mark:Mark_both env arg.mod_type mty_param + with Includemod.Error _ -> + Msupport.raise_error (apply_error ()); Tcoerce_none in let mty_appl = - match app_view.arg_path with + match arg_path with | Some path -> let scope = Ctype.create_scope () in let subst = @@ -2496,22 +2584,21 @@ and type_one_application ~ctx:(apply_loc,md_f,args) | Some param -> let parent_env = env in let env = - Env.add_module ~arg:true param Mp_present - app_view.arg.mod_type env + Env.add_module ~arg:true param Mp_present arg.mod_type env in - check_well_formed_module env app_view.loc + check_well_formed_module env app_loc "the signature of this functor application" mty_res; try Mtype.nondep_supertype env [param] mty_res with Ctype.Nondep_cannot_erase _ -> let error = Cannot_eliminate_dependency mty_functor in - raise (Error(app_view.loc, parent_env, error)) + raise (Error(app_loc, parent_env, error)) in (* TODO(merlin): we could perhaps log the "fatal error" cases... not sure it's worth the effort. *) (* begin match Includemod.modtypes - ~loc:app_view.loc ~mark:Mark_neither env mty_res nondep_mty + ~loc:app_loc ~mark:Mark_neither env mty_res nondep_mty with | Tcoerce_none -> () | _ -> @@ -2527,19 +2614,23 @@ and type_one_application ~ctx:(apply_loc,md_f,args) in check_well_formed_module env apply_loc "the signature of this functor application" mty_appl; - { mod_desc = Tmod_apply(funct, app_view.arg, coercion); + { mod_desc = Tmod_apply(funct, arg, coercion); mod_type = mty_appl; mod_env = env; - mod_attributes = app_view.attributes; - mod_loc = app_view.loc }, - Shape.app ~arg:app_view.shape funct_shape + mod_attributes = app_attributes; + mod_loc = app_loc }, + Shape.app ~arg:arg_shape funct_shape + end | Mty_alias path -> raise(Error(app_view.f_loc, env, Cannot_scrape_alias path)) - | _ -> + | Mty_ident _ | Mty_signature _ | Mty_for_hole -> let args = List.map simplify_app_summary args in let mty_f = md_f.mod_type in - let lid_app = None in - raise(Includemod.Apply_error {loc=apply_loc;env;lid_app;mty_f;args}) + let app_name = match sfunct.pmod_desc with + | Pmod_ident l -> Includemod.Named_leftmost_functor l.txt + | _ -> Includemod.Anonymous_functor + in + raise(Includemod.Apply_error {loc=apply_loc;env;app_name;mty_f;args}) and type_open_decl ?used_slot ?toplevel funct_body names env sod = Builtin_attributes.warning_scope sod.popen_attributes @@ -2619,17 +2710,17 @@ and type_structure ?(toplevel = false) ?(keep_warnings = false) funct_body ancho | Pstr_value(rec_flag, sdefs) -> let (defs, newenv) = Typecore.type_binding env rec_flag sdefs in - let () = if rec_flag = Recursive then - Typecore.check_recursive_bindings env defs + let defs = match rec_flag with + | Recursive -> Typecore.annotate_recursive_bindings env defs + | Nonrecursive -> defs in (* Note: Env.find_value does not trigger the value_used event. Values will be marked as being used during the signature inclusion test. *) let items, shape_map = List.fold_left - (fun (acc, shape_map) (id, { Asttypes.loc; _ }, _typ)-> + (fun (acc, shape_map) (id, { Asttypes.loc; _ }, _typ, _uid)-> Signature_names.check_value names loc id; let vd = Env.find_value (Pident id) newenv in - Env.register_uid vd.val_uid vd.val_loc; Sig_value(id, vd, Exported) :: acc, Shape.Map.add_value shape_map id vd.val_uid ) @@ -2643,13 +2734,14 @@ and type_structure ?(toplevel = false) ?(keep_warnings = false) funct_body ancho | Pstr_primitive sdesc -> let (desc, newenv) = Typedecl.transl_value_decl env loc sdesc in Signature_names.check_value names desc.val_loc desc.val_id; - Env.register_uid desc.val_val.val_uid desc.val_val.val_loc; Tstr_primitive desc, [Sig_value(desc.val_id, desc.val_val, Exported)], Shape.Map.add_value shape_map desc.val_id desc.val_val.val_uid, newenv | Pstr_type (rec_flag, sdecls) -> - let (decls, newenv) = Typedecl.transl_type_decl env rec_flag sdecls in + let (decls, newenv, shapes) = + Typedecl.transl_type_decl env rec_flag sdecls + in let newenv = Env.update_short_paths newenv in List.iter Signature_names.(fun td -> check_type names td.typ_loc td.typ_id) @@ -2658,32 +2750,26 @@ and type_structure ?(toplevel = false) ?(keep_warnings = false) funct_body ancho (fun rs info -> Sig_type(info.typ_id, info.typ_type, rs, Exported)) decls [] in - let shape_map = List.fold_left - (fun shape_map -> function - | Sig_type (id, vd, _, _) -> - if not (Btype.is_row_name (Ident.name id)) then begin - Env.register_uid vd.type_uid vd.type_loc; - Shape.Map.add_type shape_map id vd.type_uid - end else shape_map - | _ -> assert false - ) + let shape_map = List.fold_left2 + (fun map { typ_id; _} shape -> + Shape.Map.add_type map typ_id shape) shape_map - items + decls + shapes in Tstr_type (rec_flag, decls), items, shape_map, enrich_type_decls anchor decls env newenv | Pstr_typext styext -> - let (tyext, newenv) = + let (tyext, newenv, shapes) = Typedecl.transl_type_extension true env loc styext in let constructors = tyext.tyext_constructors in - let shape_map = List.fold_left (fun shape_map ext -> + let shape_map = List.fold_left2 (fun shape_map ext shape -> Signature_names.check_typext names ext.ext_loc ext.ext_id; - Env.register_uid ext.ext_type.ext_uid ext.ext_loc; - Shape.Map.add_extcons shape_map ext.ext_id ext.ext_type.ext_uid - ) shape_map constructors + Shape.Map.add_extcons shape_map ext.ext_id shape + ) shape_map constructors shapes in (Tstr_typext tyext, map_ext @@ -2692,13 +2778,10 @@ and type_structure ?(toplevel = false) ?(keep_warnings = false) funct_body ancho shape_map, newenv) | Pstr_exception sext -> - let (ext, newenv) = Typedecl.transl_type_exception env sext in + let (ext, newenv, shape) = Typedecl.transl_type_exception env sext in let constructor = ext.tyexn_constructor in Signature_names.check_typext names constructor.ext_loc constructor.ext_id; - Env.register_uid - constructor.ext_type.ext_uid - constructor.ext_loc; Tstr_exception ext, [Sig_typext(constructor.ext_id, constructor.ext_type, @@ -2706,7 +2789,7 @@ and type_structure ?(toplevel = false) ?(keep_warnings = false) funct_body ancho Exported)], Shape.Map.add_extcons shape_map constructor.ext_id - constructor.ext_type.ext_uid, + shape, newenv | Pstr_module {pmb_name = name; pmb_expr = smodl; pmb_attributes = attrs; pmb_loc; @@ -2734,7 +2817,6 @@ and type_structure ?(toplevel = false) ?(keep_warnings = false) funct_body ancho } in let md_shape = Shape.set_uid_if_none md_shape md_uid in - Env.register_uid md_uid pmb_loc; (*prerr_endline (Ident.unique_toplevel_name id);*) Mtype.lower_nongen outer_scope md.md_type; let id, newenv, sg = @@ -2758,8 +2840,9 @@ and type_structure ?(toplevel = false) ?(keep_warnings = false) funct_body ancho | Some id -> Shape.Map.add_module shape_map id md_shape | None -> shape_map in - Tstr_module {mb_id=id; mb_name=name; mb_expr=modl; - mb_presence=pres; mb_attributes=attrs; mb_loc=pmb_loc; }, + Tstr_module {mb_id=id; mb_name=name; mb_uid = md.md_uid; + mb_expr=modl; mb_presence=pres; mb_attributes=attrs; + mb_loc=pmb_loc; }, sg, shape_map, newenv @@ -2834,8 +2917,7 @@ and type_structure ?(toplevel = false) ?(keep_warnings = false) funct_body ancho ) bindings2 in let shape_map = - List.fold_left (fun map (id, mb, uid, shape) -> - Env.register_uid uid mb.mb_loc; + List.fold_left (fun map (id, _mb, _uid, shape) -> Shape.Map.add_module map id shape ) shape_map mbs in @@ -2855,7 +2937,6 @@ and type_structure ?(toplevel = false) ?(keep_warnings = false) funct_body ancho let newenv, mtd, decl = transl_modtype_decl env pmtd in let newenv = Env.update_short_paths newenv in Signature_names.check_modtype names pmtd.pmtd_loc mtd.mtd_id; - Env.register_uid decl.mtd_uid decl.mtd_loc; let id = mtd.mtd_id in let map = Shape.Map.add_module_type shape_map id decl.mtd_uid in Tstr_modtype mtd, [Sig_modtype (id, decl, Exported)], map, newenv @@ -2874,13 +2955,11 @@ and type_structure ?(toplevel = false) ?(keep_warnings = false) funct_body ancho Signature_names.check_class names loc cls.cls_id; Signature_names.check_class_type names loc cls.cls_ty_id; Signature_names.check_type names loc cls.cls_obj_id; - Signature_names.check_type names loc cls.cls_typesharp_id; - Env.register_uid cls.cls_decl.cty_uid loc; - let map f id acc = f acc id cls.cls_decl.cty_uid in - map Shape.Map.add_class cls.cls_id acc - |> map Shape.Map.add_class_type cls.cls_ty_id - |> map Shape.Map.add_type cls.cls_obj_id - |> map Shape.Map.add_type cls.cls_typesharp_id + let uid = cls.cls_decl.cty_uid in + let map f id v acc = f acc id v in + map Shape.Map.add_class cls.cls_id uid acc + |> map Shape.Map.add_class_type cls.cls_ty_id uid + |> map Shape.Map.add_type cls.cls_obj_id (Shape.leaf uid) ) shape_map classes in Tstr_class @@ -2893,8 +2972,8 @@ and type_structure ?(toplevel = false) ?(keep_warnings = false) funct_body ancho let open Typeclass in [Sig_class(cls.cls_id, cls.cls_decl, rs, Exported); Sig_class_type(cls.cls_ty_id, cls.cls_ty_decl, rs, Exported); - Sig_type(cls.cls_obj_id, cls.cls_obj_abbr, rs, Exported); - Sig_type(cls.cls_typesharp_id, cls.cls_abbr, rs, Exported)]) + Sig_type(cls.cls_obj_id, cls.cls_obj_abbr, rs, Exported) + ]) classes []), shape_map, new_env @@ -2906,12 +2985,10 @@ and type_structure ?(toplevel = false) ?(keep_warnings = false) funct_body ancho let loc = decl.clsty_id_loc.Location.loc in Signature_names.check_class_type names loc decl.clsty_ty_id; Signature_names.check_type names loc decl.clsty_obj_id; - Signature_names.check_type names loc decl.clsty_typesharp_id; - Env.register_uid decl.clsty_ty_decl.clty_uid loc; - let map f id acc = f acc id decl.clsty_ty_decl.clty_uid in - map Shape.Map.add_class_type decl.clsty_ty_id acc - |> map Shape.Map.add_type decl.clsty_obj_id - |> map Shape.Map.add_type decl.clsty_typesharp_id + let uid = decl.clsty_ty_decl.clty_uid in + let map f id v acc = f acc id v in + map Shape.Map.add_class_type decl.clsty_ty_id uid acc + |> map Shape.Map.add_type decl.clsty_obj_id (Shape.leaf uid) ) shape_map classes in Tstr_class_type @@ -2926,8 +3003,6 @@ and type_structure ?(toplevel = false) ?(keep_warnings = false) funct_body ancho [Sig_class_type(decl.clsty_ty_id, decl.clsty_ty_decl, rs, Exported); Sig_type(decl.clsty_obj_id, decl.clsty_obj_abbr, rs, Exported); - Sig_type(decl.clsty_typesharp_id, decl.clsty_abbr, rs, - Exported) ]) classes []), shape_map, @@ -2958,6 +3033,8 @@ and type_structure ?(toplevel = false) ?(keep_warnings = false) funct_body ancho raise (Error_forward (Builtin_attributes.error_of_extension ext)) | Pstr_attribute x -> Builtin_attributes.warning_attribute x; + if toplevel || not (Warnings.is_active (Misplaced_attribute "")) then + Builtin_attributes.mark_alert_used x; Tstr_attribute x, [], shape_map, env in let rec type_struct env shape_map sstr = @@ -3005,7 +3082,7 @@ let merlin_type_structure env str = str, sg, env let type_structure = type_structure false None let merlin_transl_signature env sg = transl_signature ~keep_warnings:true env sg -let transl_signature env sg = transl_signature env sg +let transl_signature ~toplevel env sg = transl_signature ~toplevel env sg (* Normalize types in a signature *) @@ -3042,8 +3119,7 @@ let type_module_type_of env smod = in let mty = Mtype.scrape_for_type_of ~remove_aliases env tmty.mod_type in (* PR#5036: must not contain non-generalized type variables *) - if nongen_modtype env mty then - raise(Error(smod.pmod_loc, env, Non_generalizable_module mty)); + check_nongen_modtype env smod.pmod_loc mty; tmty, mty (* For Typecore *) @@ -3086,12 +3162,16 @@ let lookup_type_in_sig sg = let type_package env m p fl = (* Same as Pexp_letmodule *) - (* remember original level *) - Ctype.begin_def (); - let context = Typetexp.narrow () in - let modl, _mod_shape = type_module env m in - let scope = Ctype.create_scope () in - Typetexp.widen context; + let modl, scope = + Typetexp.TyVarEnv.with_local_scope begin fun () -> + (* type the module and create a scope in a raised level *) + Ctype.with_local_level begin fun () -> + let modl, _mod_shape = type_module env m in + let scope = Ctype.create_scope () in + modl, scope + end + end + in let fl', env = match fl with | [] -> [], env @@ -3132,8 +3212,6 @@ let type_package env m p fl = in fl', env in - (* go back to original level *) - Ctype.end_def (); let mty = if fl = [] then (Mty_ident p) else modtype_of_package env modl.mod_loc p fl' @@ -3144,7 +3222,7 @@ let type_package env m p fl = with Ctype.Unify _ -> raise (Error(modl.mod_loc, env, Scoping_pack (n,ty)))) fl'; - let modl = wrap_constraint env true modl mty Tmodtype_implicit in + let modl = wrap_constraint_package env true modl mty Tmodtype_implicit in modl, fl' (* Fill in the forward declarations *) @@ -3161,6 +3239,7 @@ let () = Typetexp.transl_modtype_longident := transl_modtype_longident; Typetexp.transl_modtype := transl_modtype; Typecore.type_open := type_open_ ?toplevel:None; + Typetexp.type_open := type_open_ ?toplevel:None; Typecore.type_open_decl := type_open_decl; Typecore.type_package := type_package; Typeclass.type_open_descr := type_open_descr; @@ -3168,8 +3247,22 @@ let () = (* Typecheck an implementation file *) +(* +let gen_annot target annots = + let annot = Unit_info.annot target in + Cmt2annot.gen_annot (Some (Unit_info.Artifact.filename annot)) + ~sourcefile:(Unit_info.Artifact.source_file annot) + ~use_summaries:false + annots +*) -let type_implementation sourcefile outputprefix modulename initial_env ast = +let type_implementation target initial_env ast = + let sourcefile = Unit_info.source_file target in + let save_cmt target annots initial_env cmi shape = + Cmt_format.save_cmt (Unit_info.cmt target) + annots initial_env cmi shape; + (* gen_annot target annots; *) + in Cmt_format.clear (); Misc.try_finally (fun () -> Typecore.reset_delayed_checks (); @@ -3179,52 +3272,57 @@ let type_implementation sourcefile outputprefix modulename initial_env ast = let (str, sg, names, shape, finalenv) = type_structure initial_env ast in let shape = - Shape.set_uid_if_none shape - (Uid.of_compilation_unit_id (Ident.create_persistent modulename)) + let id = Ident.create_persistent @@ Unit_info.modname target in + Shape.set_uid_if_none shape (Uid.of_compilation_unit_id id) in let simple_sg = Signature_names.simplify finalenv names sg in if !Clflags.print_types then begin Typecore.force_delayed_checks (); - let shape = Shape.local_reduce shape in + let shape = Shape_reduce.local_reduce Env.empty shape in Printtyp.wrap_printing_env ~error:false initial_env (fun () -> fprintf std_formatter "%a@." - (Printtyp.printed_signature sourcefile) simple_sg + (Printtyp.printed_signature @@ Unit_info.source_file target) + simple_sg ); + (* gen_annot target (Cmt_format.Implementation str); *) { structure = str; coercion = Tcoerce_none; shape; signature = simple_sg } (* result is ignored by Compile.implementation *) end else begin - let sourceintf = - Filename.remove_extension sourcefile ^ !Config.interface_suffix in - if Sys.file_exists sourceintf then begin - let intf_file = - try - Load_path.find_uncap (modulename ^ ".cmi") - with Not_found -> - raise(Error(Location.in_file sourcefile, Env.empty, - Interface_not_compiled sourceintf)) in - let dclsig = Env.read_signature modulename intf_file in + let source_intf = Unit_info.mli_from_source target in + if !Clflags.cmi_file <> None + || Sys.file_exists source_intf then begin + let compiled_intf_file = + match !Clflags.cmi_file with + | Some cmi_file -> Unit_info.Artifact.from_filename cmi_file + | None -> + try Unit_info.find_normalized_cmi target with Not_found -> + raise(Error(Location.in_file sourcefile, Env.empty, + Interface_not_compiled source_intf)) + in + let dclsig = Env.read_signature compiled_intf_file in let coercion, shape = Includemod.compunit initial_env ~mark:Mark_positive - sourcefile sg intf_file dclsig shape + sourcefile sg source_intf + dclsig shape in Typecore.force_delayed_checks (); (* It is important to run these checks after the inclusion test above, so that value declarations which are not used internally but exported are not reported as being unused. *) - let shape = Shape.local_reduce shape in + let shape = Shape_reduce.local_reduce Env.empty shape in let annots = Cmt_format.Implementation str in - Cmt_format.save_cmt (outputprefix ^ ".cmt") modulename - annots (Some sourcefile) initial_env None (Some shape); + save_cmt target annots initial_env None (Some shape); { structure = str; coercion; shape; signature = dclsig } end else begin - Location.prerr_warning (Location.in_file sourcefile) + Location.prerr_warning + (Location.in_file (Unit_info.source_file target)) Warnings.Missing_mli; let coercion, shape = Includemod.compunit initial_env ~mark:Mark_positive @@ -3234,19 +3332,17 @@ let type_implementation sourcefile outputprefix modulename initial_env ast = normalize_signature simple_sg; Typecore.force_delayed_checks (); (* See comment above. Here the target signature contains all - the value being exported. We can still capture unused + the values being exported. We can still capture unused declarations like "let x = true;; let x = 1;;", because in this case, the inferred signature contains only the last declaration. *) - let shape = Shape.local_reduce shape in + let shape = Shape_reduce.local_reduce Env.empty shape in if not !Clflags.dont_write_files then begin let alerts = Builtin_attributes.alerts_of_str ast in let cmi = - Env.save_signature ~alerts - simple_sg modulename (outputprefix ^ ".cmi") + Env.save_signature ~alerts simple_sg (Unit_info.cmi target) in let annots = Cmt_format.Implementation str in - Cmt_format.save_cmt (outputprefix ^ ".cmt") modulename - annots (Some sourcefile) initial_env (Some cmi) (Some shape); + save_cmt target annots initial_env (Some cmi) (Some shape) end; { structure = str; coercion; @@ -3261,16 +3357,18 @@ let type_implementation sourcefile outputprefix modulename initial_env ast = Cmt_format.Partial_implementation (Array.of_list (Cmt_format.get_saved_types ())) in - Cmt_format.save_cmt (outputprefix ^ ".cmt") modulename - annots (Some sourcefile) initial_env None None; + save_cmt target annots initial_env None None ) -let save_signature modname tsg outputprefix source_file initial_env cmi = - Cmt_format.save_cmt (outputprefix ^ ".cmti") modname - (Cmt_format.Interface tsg) (Some source_file) initial_env (Some cmi) None +let save_signature target tsg initial_env cmi = + Cmt_format.save_cmt (Unit_info.cmti target) + (Cmt_format.Interface tsg) initial_env (Some cmi) None let type_interface env ast = - transl_signature env ast + transl_signature ~toplevel:true env ast + +let transl_signature env ast = + transl_signature ~toplevel:false env ast (* "Packaging" of several compilation units into one unit having them as sub-modules. *) @@ -3305,25 +3403,24 @@ let package_signatures units = Sig_module(newid, Mp_present, md, Trec_not, Exported)) units_with_ids -let package_units initial_env objfiles cmifile modulename = +let package_units initial_env objfiles target_cmi = (* Read the signatures of the units *) let units = List.map (fun f -> - let pref = chop_extensions f in - let modname = String.capitalize_ascii(Filename.basename pref) in - let sg = Env.read_signature modname (pref ^ ".cmi") in - if Filename.check_suffix f ".cmi" && - not(Mtype.no_code_needed_sig Env.initial_safe_string sg) + let artifact = Unit_info.Artifact.from_filename f in + let sg = Env.read_signature (Unit_info.companion_cmi artifact) in + if Unit_info.is_cmi artifact && + not(Mtype.no_code_needed_sig Env.initial sg) then raise(Error(Location.none, Env.empty, Implementation_is_required f)); - (modname, Env.read_signature modname (pref ^ ".cmi"))) + Unit_info.Artifact.modname artifact, sg) objfiles in (* Compute signature of packaged unit *) Ident.reinit(); let sg = package_signatures units in (* Compute the shape of the package *) - let prefix = Filename.remove_extension cmifile in + let prefix = Unit_info.Artifact.prefix target_cmi in let pack_uid = Uid.of_compilation_unit_id (Ident.create_persistent prefix) in let shape = List.fold_left (fun map (name, _sg) -> @@ -3333,19 +3430,20 @@ let package_units initial_env objfiles cmifile modulename = |> Shape.str ~uid:pack_uid in (* See if explicit interface is provided *) - let mlifile = prefix ^ !Config.interface_suffix in - if Sys.file_exists mlifile then begin - if not (Sys.file_exists cmifile) then begin - raise(Error(Location.in_file mlifile, Env.empty, - Interface_not_compiled mlifile)) + let mli = Unit_info.mli_from_artifact target_cmi in + if Sys.file_exists mli then begin + if not (Sys.file_exists @@ Unit_info.Artifact.filename target_cmi) then + begin + raise(Error(Location.in_file mli, Env.empty, + Interface_not_compiled mli)) end; - let dclsig = Env.read_signature modulename cmifile in + let dclsig = Env.read_signature target_cmi in let cc, _shape = Includemod.compunit initial_env ~mark:Mark_both - "(obtained by packing)" sg mlifile dclsig shape + "(obtained by packing)" sg mli dclsig shape in - Cmt_format.save_cmt (prefix ^ ".cmt") modulename - (Cmt_format.Packed (sg, objfiles)) None initial_env None (Some shape); + Cmt_format.save_cmt (Unit_info.companion_cmt target_cmi) + (Cmt_format.Packed (sg, objfiles)) initial_env None (Some shape); cc end else begin (* Determine imports *) @@ -3358,11 +3456,10 @@ let package_units initial_env objfiles cmifile modulename = if not !Clflags.dont_write_files then begin let cmi = Env.save_signature_with_imports ~alerts:Misc.String.Map.empty - sg modulename - (prefix ^ ".cmi") imports + sg target_cmi imports in - Cmt_format.save_cmt (prefix ^ ".cmt") modulename - (Cmt_format.Packed (cmi.Cmi_format.cmi_sign, objfiles)) None initial_env + Cmt_format.save_cmt (Unit_info.companion_cmt target_cmi) + (Cmt_format.Packed (cmi.Cmi_format.cmi_sign, objfiles)) initial_env (Some cmi) (Some shape); end; Tcoerce_none @@ -3377,7 +3474,8 @@ open Printtyp let report_error ~loc _env = function Cannot_apply mty -> Location.errorf ~loc - "@[This module is not a functor; it has type@ %a@]" modtype mty + "@[This module is not a functor; it has type@ %a@]" + (Style.as_inline_code modtype) mty | Not_included errs -> let main = Includemod_errorprinter.err_msgs errs in Location.errorf ~loc "@[Signature mismatch:@ %t@]" main @@ -3385,61 +3483,109 @@ let report_error ~loc _env = function Location.errorf ~loc "@[This functor has type@ %a@ \ The parameter cannot be eliminated in the result type.@ \ - Please bind the argument to a module identifier.@]" modtype mty + Please bind the argument to a module identifier.@]" + (Style.as_inline_code modtype) mty | Signature_expected -> Location.errorf ~loc "This module type is not a signature" | Structure_expected mty -> Location.errorf ~loc - "@[This module is not a structure; it has type@ %a" modtype mty + "@[This module is not a structure; it has type@ %a" + (Style.as_inline_code modtype) mty | With_no_component lid -> Location.errorf ~loc - "@[The signature constrained by `with' has no component named %a@]" - longident lid + "@[The signature constrained by %a has no component named %a@]" + Style.inline_code "with" + (Style.as_inline_code longident) lid | With_mismatch(lid, explanation) -> let main = Includemod_errorprinter.err_msgs explanation in Location.errorf ~loc "@[\ - @[In this `with' constraint, the new definition of %a@ \ + @[In this %a constraint, the new definition of %a@ \ does not match its original definition@ \ in the constrained signature:@]@ \ - %t@]" - longident lid main + %t@]" + Style.inline_code "with" + (Style.as_inline_code longident) lid main | With_makes_applicative_functor_ill_typed(lid, path, explanation) -> let main = Includemod_errorprinter.err_msgs explanation in Location.errorf ~loc "@[\ - @[This `with' constraint on %a makes the applicative functor @ \ - type %s ill-typed in the constrained signature:@]@ \ - %t@]" - longident lid (Path.name path) main + @[This %a constraint on %a makes the applicative functor @ \ + type %a ill-typed in the constrained signature:@]@ \ + %t@]" + Style.inline_code "with" + (Style.as_inline_code longident) lid + Style.inline_code (Path.name path) + main | With_changes_module_alias(lid, id, path) -> Location.errorf ~loc "@[\ - @[This `with' constraint on %a changes %s, which is aliased @ \ - in the constrained signature (as %s)@].@]" - longident lid (Path.name path) (Ident.name id) + @[This %a constraint on %a changes %a, which is aliased @ \ + in the constrained signature (as %a)@].@]" + Style.inline_code "with" + (Style.as_inline_code longident) lid + Style.inline_code (Path.name path) + Style.inline_code (Ident.name id) | With_cannot_remove_constrained_type -> Location.errorf ~loc "@[Destructive substitutions are not supported for constrained @ \ types (other than when replacing a type constructor with @ \ a type constructor with the same arguments).@]" | With_cannot_remove_packed_modtype (p,mty) -> + let[@manual.ref "ss:module-type-substitution"] manual_ref = + [ 12; 7; 3 ] + in + let pp_constraint ppf () = + Format.fprintf ppf "%s := %a" + (Path.name p) Printtyp.modtype mty + in + Location.errorf ~loc + "This %a constraint@ %a@ makes a packed module ill-formed.@ %a" + Style.inline_code "with" + (Style.as_inline_code pp_constraint) () + Misc.print_see_manual manual_ref + | With_package_manifest (lid, ty) -> Location.errorf ~loc - "This `with' constraint@ %s := %a@ makes a packed module ill-formed." - (Path.name p) Printtyp.modtype mty + "In the constrained signature, type %a is defined to be %a.@ \ + Package %a constraints may only be used on abstract types." + (Style.as_inline_code longident) lid + (Style.as_inline_code Printtyp.type_expr) ty + Style.inline_code "with" | Repeated_name(kind, name) -> Location.errorf ~loc - "@[Multiple definition of the %s name %s.@ \ + "@[Multiple definition of the %s name %a.@ \ Names must be unique in a given structure or signature.@]" - (Sig_component_kind.to_string kind) name - | Non_generalizable typ -> + (Sig_component_kind.to_string kind) Style.inline_code name + | Non_generalizable { vars; expression } -> + let[@manual.ref "ss:valuerestriction"] manual_ref = [ 6; 1; 2 ] in + prepare_for_printing vars; + add_type_to_preparation expression; Location.errorf ~loc "@[The type of this expression,@ %a,@ \ - contains type variables that cannot be generalized@]" type_scheme typ - | Non_generalizable_module mty -> - Location.errorf ~loc + contains the non-generalizable type variable(s): %a.@ %a@]" + (Style.as_inline_code prepared_type_scheme) expression + (pp_print_list ~pp_sep:(fun f () -> fprintf f ",@ ") + (Style.as_inline_code prepared_type_scheme)) vars + Misc.print_see_manual manual_ref + | Non_generalizable_module { vars; mty; item } -> + let[@manual.ref "ss:valuerestriction"] manual_ref = [ 6; 1; 2 ] in + prepare_for_printing vars; + add_type_to_preparation item.val_type; + let sub = + [ Location.msg ~loc:item.val_loc + "The type of this value,@ %a,@ \ + contains the non-generalizable type variable(s) %a." + (Style.as_inline_code prepared_type_scheme) + item.val_type + (pp_print_list ~pp_sep:(fun f () -> fprintf f ",@ ") + @@ Style.as_inline_code prepared_type_scheme) vars + ] + in + Location.errorf ~loc ~sub "@[The type of this module,@ %a,@ \ - contains type variables that cannot be generalized@]" modtype mty + contains non-generalizable type variable(s).@ %a@]" + modtype mty + Misc.print_see_manual manual_ref | Implementation_is_required intf_name -> Location.errorf ~loc "@[The interface %a@ declares values, not just types.@ \ @@ -3456,62 +3602,89 @@ let report_error ~loc _env = function | Not_a_packed_module ty -> Location.errorf ~loc "This expression is not a packed module. It has type@ %a" - type_expr ty + (Style.as_inline_code type_expr) ty | Incomplete_packed_module ty -> Location.errorf ~loc "The type of this packed module contains variables:@ %a" - type_expr ty + (Style.as_inline_code type_expr) ty | Scoping_pack (lid, ty) -> Location.errorf ~loc "The type %a in this module cannot be exported.@ \ - Its type contains local dependencies:@ %a" longident lid type_expr ty + Its type contains local dependencies:@ %a" + (Style.as_inline_code longident) lid + (Style.as_inline_code type_expr) ty | Recursive_module_require_explicit_type -> Location.errorf ~loc "Recursive modules require an explicit module type." | Apply_generative -> Location.errorf ~loc - "This is a generative functor. It can only be applied to ()" + "This is a generative functor. It can only be applied to %a" + Style.inline_code "()" | Cannot_scrape_alias p -> Location.errorf ~loc "This is an alias for module %a, which is missing" - path p + (Style.as_inline_code path) p | Cannot_scrape_package_type p -> Location.errorf ~loc "The type of this packed module refers to %a, which is missing" - path p + (Style.as_inline_code path) p | Badly_formed_signature (context, err) -> Location.errorf ~loc "@[In %s:@ %a@]" context Typedecl.report_error err | Cannot_hide_id Illegal_shadowing { shadowed_item_kind; shadowed_item_id; shadowed_item_loc; shadower_id; user_id; user_kind; user_loc } -> + let shadowed = + Printtyp.namespaced_ident shadowed_item_kind shadowed_item_id + in + let shadower = + Printtyp.namespaced_ident shadowed_item_kind shadower_id + in let shadowed_item_kind= Sig_component_kind.to_string shadowed_item_kind in - Location.errorf ~loc - "@[Illegal shadowing of included %s %a by %a@ \ - %a:@;<1 2>%s %a came from this include@ \ - %a:@;<1 2>The %s %s has no valid type if %a is shadowed@]" - shadowed_item_kind Ident.print shadowed_item_id Ident.print shadower_id - Location.print_loc shadowed_item_loc - (String.capitalize_ascii shadowed_item_kind) - Ident.print shadowed_item_id - Location.print_loc user_loc - (Sig_component_kind.to_string user_kind) (Ident.name user_id) - Ident.print shadowed_item_id + let shadowed_msg = + Location.msg ~loc:shadowed_item_loc + "@[%s %a came from this include.@]" + (String.capitalize_ascii shadowed_item_kind) + Style.inline_code shadowed + in + let user_msg = + Location.msg ~loc:user_loc + "@[The %s %a has no valid type@ if %a is shadowed.@]" + (Sig_component_kind.to_string user_kind) + Style.inline_code (Ident.name user_id) + Style.inline_code shadowed + in + Location.errorf ~loc ~sub:[shadowed_msg; user_msg] + "Illegal shadowing of included %s %a@ by %a." + shadowed_item_kind + Style.inline_code shadowed + Style.inline_code shadower | Cannot_hide_id Appears_in_signature { opened_item_kind; opened_item_id; user_id; user_kind; user_loc } -> let opened_item_kind= Sig_component_kind.to_string opened_item_kind in - Location.errorf ~loc - "@[The %s %a introduced by this open appears in the signature@ \ - %a:@;<1 2>The %s %s has no valid type if %a is hidden@]" - opened_item_kind Ident.print opened_item_id - Location.print_loc user_loc - (Sig_component_kind.to_string user_kind) (Ident.name user_id) - Ident.print opened_item_id + let opened_id = Ident.name opened_item_id in + let user_msg = + Location.msg ~loc:user_loc + "@[The %s %a has no valid type@ if %a is hidden.@]" + (Sig_component_kind.to_string user_kind) + Style.inline_code (Ident.name user_id) + Style.inline_code opened_id + in + Location.errorf ~loc ~sub:[user_msg] + "The %s %a introduced by this open appears in the signature." + opened_item_kind + Style.inline_code opened_id | Invalid_type_subst_rhs -> - Location.errorf ~loc "Only type synonyms are allowed on the right of :=" + Location.errorf ~loc "Only type synonyms are allowed on the right of %a" + Style.inline_code ":=" | Unpackable_local_modtype_subst p -> + let[@manual.ref "ss:module-type-substitution"] manual_ref = + [ 12; 7; 3 ] + in Location.errorf ~loc - "The module type@ %s@ is not a valid type for a packed module:@ \ - it is defined as a local substitution for a non-path module type." - (Path.name p) + "The module type@ %a@ is not a valid type for a packed module:@ \ + it is defined as a local substitution (temporary name)@ \ + for an anonymous module type.@ %a" + Style.inline_code (Path.name p) + Misc.print_see_manual manual_ref let report_error env ~loc err = Printtyp.wrap_printing_env ~error:true env diff --git a/src/ocaml/typing/typemod.mli b/src/ocaml/typing/typemod.mli index 6f4075882b..d88d5b247f 100644 --- a/src/ocaml/typing/typemod.mli +++ b/src/ocaml/typing/typemod.mli @@ -39,8 +39,8 @@ val type_toplevel_phrase: Typedtree.structure * Types.signature * (* Signature_names.t * *) Shape.t * Env.t val type_implementation: - string -> string -> string -> Env.t -> - Parsetree.structure -> Typedtree.implementation + Unit_info.t -> Env.t -> Parsetree.structure -> + Typedtree.implementation val type_interface: Env.t -> Parsetree.signature -> Typedtree.signature val transl_signature: @@ -60,15 +60,15 @@ val modtype_of_package: val path_of_module : Typedtree.module_expr -> Path.t option val save_signature: - string -> Typedtree.signature -> string -> string -> - Env.t -> Cmi_format.cmi_infos -> unit + Unit_info.t -> Typedtree.signature -> Env.t -> + Cmi_format.cmi_infos -> unit val package_units: - Env.t -> string list -> string -> string -> Typedtree.module_coercion + Env.t -> string list -> Unit_info.Artifact.t -> Typedtree.module_coercion (* Should be in Envaux, but it breaks the build of the debugger *) val initial_env: - loc:Location.t -> safe_string:bool -> + loc:Location.t -> initially_opened_module:string option -> open_implicit_modules:string list -> Env.t @@ -76,6 +76,8 @@ module Sig_component_kind : sig type t = | Value | Type + | Constructor + | Label | Module | Module_type | Extension_constructor @@ -115,9 +117,11 @@ type error = Longident.t * Path.t * Includemod.explanation | With_changes_module_alias of Longident.t * Ident.t * Path.t | With_cannot_remove_constrained_type + | With_package_manifest of Longident.t * type_expr | Repeated_name of Sig_component_kind.t * string - | Non_generalizable of type_expr - | Non_generalizable_module of module_type + | Non_generalizable of { vars : type_expr list; expression : type_expr } + | Non_generalizable_module of + { vars : type_expr list; item : value_description; mty : module_type } | Implementation_is_required of string | Interface_not_compiled of string | Not_allowed_in_functor_body diff --git a/src/ocaml/typing/typeopt.ml b/src/ocaml/typing/typeopt.ml index 7462e16a09..f983c499c7 100644 --- a/src/ocaml/typing/typeopt.ml +++ b/src/ocaml/typing/typeopt.ml @@ -18,6 +18,7 @@ open Types open Asttypes open Typedtree +open Lambda let scrape_ty env ty = match get_desc ty with @@ -43,7 +44,7 @@ let scrape_ty env ty = let scrape env ty = get_desc (scrape_ty env ty) -let _scrape_poly env ty = +let scrape_poly env ty = let ty = scrape_ty env ty in match get_desc ty with | Tpoly (ty, _) -> get_desc ty @@ -67,6 +68,13 @@ let is_immediate = function targeting 32 or 64 bits. *) !Clflags.native_code && Sys.word_size = 64 +let maybe_pointer_type env ty = + let ty = scrape_ty env ty in + if is_immediate (Ctype.immediacy env ty) then Immediate + else Pointer + +let maybe_pointer exp = maybe_pointer_type exp.exp_env exp.exp_type + type classification = | Int | Float @@ -92,7 +100,7 @@ let classify env ty = else begin try match (Env.find_type p env).type_kind with - | Type_abstract -> + | Type_abstract _ -> Any | Type_record _ | Type_variant _ | Type_open -> Addr @@ -107,7 +115,6 @@ let classify env ty = | Tlink _ | Tsubst _ | Tpoly _ | Tfield _ -> assert false -(* let array_type_kind env ty = match scrape_poly env ty with | Tconstr(p, [elt_ty], _) when Path.same p Predef.path_array -> @@ -125,6 +132,7 @@ let array_type_kind env ty = let array_kind exp = array_type_kind exp.exp_env exp.exp_type +(* let array_pattern_kind pat = array_type_kind pat.pat_env pat.pat_type let bigarray_decode_type env ty tbl dfl = @@ -136,7 +144,8 @@ let bigarray_decode_type env ty tbl dfl = dfl let kind_table = - ["float32_elt", Pbigarray_float32; + ["float16_elt", Pbigarray_float16; + "float32_elt", Pbigarray_float32; "float64_elt", Pbigarray_float64; "int8_signed_elt", Pbigarray_sint8; "int8_unsigned_elt", Pbigarray_uint8; @@ -178,11 +187,6 @@ let value_kind env ty = | _ -> Pgenval end - -let function_return_value_kind env ty = - match is_function_type env ty with - | Some (_lhs, rhs) -> value_kind env rhs - | None -> Pgenval *) (** Whether a forward block is needed for a lazy thunk on a value, i.e. diff --git a/src/ocaml/typing/typeopt.mli b/src/ocaml/typing/typeopt.mli index 6ca678d2fe..1e7c1ecb79 100644 --- a/src/ocaml/typing/typeopt.mli +++ b/src/ocaml/typing/typeopt.mli @@ -19,18 +19,18 @@ val is_function_type : Env.t -> Types.type_expr -> (Types.type_expr * Types.type_expr) option val is_base_type : Env.t -> Types.type_expr -> Path.t -> bool -(* val maybe_pointer_type : Env.t -> Types.type_expr -> Lambda.immediate_or_pointer val maybe_pointer : Typedtree.expression -> Lambda.immediate_or_pointer val array_type_kind : Env.t -> Types.type_expr -> Lambda.array_kind + val array_kind : Typedtree.expression -> Lambda.array_kind +(* val array_pattern_kind : Typedtree.pattern -> Lambda.array_kind val bigarray_type_kind_and_layout : Env.t -> Types.type_expr -> Lambda.bigarray_kind * Lambda.bigarray_layout val value_kind : Env.t -> Types.type_expr -> Lambda.value_kind -val function_return_value_kind : Env.t -> Types.type_expr -> Lambda.value_kind *) val classify_lazy_argument : Typedtree.expression -> diff --git a/src/ocaml/typing/types.ml b/src/ocaml/typing/types.ml index 1112c4a68d..bdc2a9e549 100644 --- a/src/ocaml/typing/types.ml +++ b/src/ocaml/typing/types.ml @@ -134,36 +134,70 @@ and method_privacy = | Mprivate of field_kind (* Variance *) +(* Variance forms a product lattice of the following partial orders: + 0 <= may_pos <= pos + 0 <= may_weak <= may_neg <= neg + 0 <= inj + Additionally, the following implications are valid + pos => inj + neg => inj + Examples: + type 'a t : may_pos + may_neg + may_weak + type 'a t = 'a : pos + type 'a t = 'a -> unit : neg + type 'a t = ('a -> unit) -> unit : pos + may_weak + type 'a t = A of (('a -> unit) -> unit) : pos + type +'a p = .. : may_pos + inj + type +!'a t : may_pos + inj + type -!'a t : may_neg + inj + type 'a t = A : inj + *) module Variance = struct type t = int type f = May_pos | May_neg | May_weak | Inj | Pos | Neg | Inv let single = function | May_pos -> 1 - | May_neg -> 2 + | May_neg -> 2 + 4 | May_weak -> 4 | Inj -> 8 - | Pos -> 16 - | Neg -> 32 - | Inv -> 64 + | Pos -> 16 + 8 + 1 + | Neg -> 32 + 8 + 4 + 2 + | Inv -> 63 let union v1 v2 = v1 lor v2 let inter v1 v2 = v1 land v2 let subset v1 v2 = (v1 land v2 = v1) let eq (v1 : t) v2 = (v1 = v2) - let set x b v = - if b then v lor single x else v land (lnot (single x)) + let set x v = union v (single x) + let set_if b x v = if b then set x v else v let mem x = subset (single x) let null = 0 let unknown = 7 - let full = 127 - let covariant = single May_pos lor single Pos lor single Inj - let swap f1 f2 v = - let v' = set f1 (mem f2 v) v in set f2 (mem f1 v) v' - let conjugate v = swap May_pos May_neg (swap Pos Neg v) + let full = single Inv + let covariant = single Pos + let swap f1 f2 v v' = + set_if (mem f2 v) f1 (set_if (mem f1 v) f2 v') + let conjugate v = + let v' = inter v (union (single Inj) (single May_weak)) in + swap Pos Neg v (swap May_pos May_neg v v') + let compose v1 v2 = + if mem Inv v1 && mem Inj v2 then full else + let mp = + mem May_pos v1 && mem May_pos v2 || mem May_neg v1 && mem May_neg v2 + and mn = + mem May_pos v1 && mem May_neg v2 || mem May_neg v1 && mem May_pos v2 + and mw = mem May_weak v1 && v2 <> null || v1 <> null && mem May_weak v2 + and inj = mem Inj v1 && mem Inj v2 + and pos = mem Pos v1 && mem Pos v2 || mem Neg v1 && mem Neg v2 + and neg = mem Pos v1 && mem Neg v2 || mem Neg v1 && mem Pos v2 in + List.fold_left (fun v (b,f) -> set_if b f v) null + [mp, May_pos; mn, May_neg; mw, May_weak; inj, Inj; pos, Pos; neg, Neg] + let strengthen v = + if mem May_neg v then v else v land (full - single May_weak) let get_upper v = (mem May_pos v, mem May_neg v) - let get_lower v = (mem Pos v, mem Neg v, mem Inv v, mem Inj v) + let get_lower v = (mem Pos v, mem Neg v, mem Inj v) let unknown_signature ~injective ~arity = - let v = if injective then set Inj true unknown else unknown in + let v = if injective then set Inj unknown else unknown in Misc.replicate_list v arity end @@ -215,11 +249,16 @@ type type_declaration = and type_decl_kind = (label_declaration, constructor_declaration) type_kind and ('lbl, 'cstr) type_kind = - Type_abstract + Type_abstract of type_origin | Type_record of 'lbl list * record_representation | Type_variant of 'cstr list * variant_representation | Type_open +and type_origin = + Definition + | Rec_check_regularity + | Existential of string + and record_representation = Record_regular (* All fields are boxed / tagged *) | Record_float (* All fields are floats *) @@ -293,6 +332,7 @@ type class_type_declaration = { clty_params: type_expr list; clty_type: class_type; clty_path: Path.t; + clty_hash_type: type_declaration; clty_variance: Variance.t list; clty_loc: Location.t; clty_attributes: Parsetree.attributes; diff --git a/src/ocaml/typing/types.mli b/src/ocaml/typing/types.mli index e087532159..d7a782da3e 100644 --- a/src/ocaml/typing/types.mli +++ b/src/ocaml/typing/types.mli @@ -418,11 +418,14 @@ module Variance : sig val inter : t -> t -> t val subset : t -> t -> bool val eq : t -> t -> bool - val set : f -> bool -> t -> t + val set : f -> t -> t + val set_if : bool -> f -> t -> t val mem : f -> t -> bool val conjugate : t -> t (* exchange positive and negative *) - val get_upper : t -> bool * bool (* may_pos, may_neg *) - val get_lower : t -> bool * bool * bool * bool (* pos, neg, inv, inj *) + val compose : t -> t -> t + val strengthen : t -> t (* remove May_weak when possible *) + val get_upper : t -> bool * bool (* may_pos, may_neg *) + val get_lower : t -> bool * bool * bool (* pos, neg, inj *) val unknown_signature : injective:bool -> arity:int -> t list (** The most pessimistic variance for a completely unknown type. *) end @@ -483,17 +486,23 @@ type type_declaration = and type_decl_kind = (label_declaration, constructor_declaration) type_kind and ('lbl, 'cstr) type_kind = - Type_abstract + Type_abstract of type_origin | Type_record of 'lbl list * record_representation | Type_variant of 'cstr list * variant_representation | Type_open +and type_origin = + Definition + | Rec_check_regularity (* See Typedecl.transl_type_decl *) + | Existential of string + and record_representation = Record_regular (* All fields are boxed / tagged *) | Record_float (* All fields are floats *) | Record_unboxed of bool (* Unboxed single-field record, inlined or not *) | Record_inlined of int (* Inlined record *) | Record_extension of Path.t (* Inlined record under extension *) + (* The argument is the path of the extension *) and variant_representation = Variant_regular (* Constant or boxed constructors *) @@ -562,6 +571,7 @@ type class_type_declaration = { clty_params: type_expr list; clty_type: class_type; clty_path: Path.t; + clty_hash_type: type_declaration; (* object type with an open row *) clty_variance: Variance.t list; clty_loc: Location.t; clty_attributes: Parsetree.attributes; diff --git a/src/ocaml/typing/typetexp.ml b/src/ocaml/typing/typetexp.ml index bc0007b09c..78d4fa883d 100644 --- a/src/ocaml/typing/typetexp.ml +++ b/src/ocaml/typing/typetexp.ml @@ -27,12 +27,12 @@ open Ctype exception Already_bound type error = - Unbound_type_variable of string + | Unbound_type_variable of string * string list + | No_type_wildcards | Undefined_type_constructor of Path.t | Type_arity_mismatch of Longident.t * int * int | Bound_type_variable of string | Recursive_type - | Unbound_row_variable of Longident.t | Type_mismatch of Errortrace.unification_error | Alias_type_mismatch of Errortrace.unification_error | Present_has_conjunction of string @@ -51,59 +51,306 @@ exception Error of Location.t * Env.t * error exception Error_forward of Location.error (** Map indexed by type variable names. *) -module TyVarMap = Misc.String.Map +module TyVarEnv : sig + val reset : unit -> unit + (* see mli file *) + val is_in_scope : string -> bool + + val add : string -> type_expr -> unit + (* add a global type variable to the environment *) + + val with_local_scope : (unit -> 'a) -> 'a + (* see mli file *) + + type poly_univars + val with_univars : poly_univars -> (unit -> 'a) -> 'a + (* evaluate with a locally extended set of univars *) + + val make_poly_univars : string list -> poly_univars + (* see mli file *) + + val check_poly_univars : Env.t -> Location.t -> poly_univars -> type_expr list + (* see mli file *) + + val instance_poly_univars : + Env.t -> Location.t -> poly_univars -> type_expr list + (* see mli file *) + + type policy + val fixed_policy : policy (* no wildcards allowed *) + val extensible_policy : policy (* common case *) + val univars_policy : policy (* fresh variables are univars (in methods) *) + val new_any_var : Location.t -> Env.t -> policy -> type_expr + (* create a new variable to represent a _; fails for fixed_policy *) + val new_var : ?name:string -> policy -> type_expr + (* create a new variable according to the given policy *) + + val add_pre_univar : type_expr -> policy -> unit + (* remember that a variable might become a univar if it isn't unified; + used for checking method types *) + + val collect_univars : (unit -> 'a) -> 'a * type_expr list + (* collect univars during a computation; returns the univars. + The wrapped computation should use [univars_policy]. + postcondition: the returned type_exprs are all Tunivar *) + + val reset_locals : ?univars:poly_univars -> unit -> unit + (* clear out the local type variable env't; call this when starting + a new e.g. type signature. Optionally pass some univars that + are in scope. *) + + val lookup_local : + row_context:type_expr option ref list -> string -> type_expr + (* look up a local type variable; throws Not_found if it isn't in scope *) + + val remember_used : string -> type_expr -> Location.t -> unit + (* remember that a given name is bound to a given type *) + + val globalize_used_variables : policy -> Env.t -> unit -> unit + (* after finishing with a type signature, used variables are unified to the + corresponding global type variables if they exist. Otherwise, in function + of the policy, fresh used variables are either + - added to the global type variable scope if they are not longer + variables under the {!fixed_policy} + - added to the global type variable scope under the {!extensible_policy} + - expected to be collected later by a call to `collect_univar` under the + {!universal_policy} + *) + +end = struct + (** Map indexed by type variable names. *) + module TyVarMap = Misc.String.Map + + let not_generic v = get_level v <> Btype.generic_level + + (* These are the "global" type variables: they were in scope before + we started processing the current type. + *) + let type_variables = ref (TyVarMap.empty : type_expr TyVarMap.t) + + (* These are variables that have been used in the currently-being-checked + type. + *) + let used_variables = + ref (TyVarMap.empty : (type_expr * Location.t) TyVarMap.t) + + (* These are variables we expect to become univars (they were introduced with + e.g. ['a .]), but we need to make sure they don't unify first. Why not + just birth them as univars? Because they might successfully unify with a + row variable in the ['a. < m : ty; .. > as 'a] idiom. They are like the + [used_variables], but will not be globalized in [globalize_used_variables]. + *) + type pending_univar = { + univar: type_expr (** the univar itself *); + mutable associated: type_expr option ref list + (** associated references to row variables that we want to generalize + if possible *) + } + + let univars = ref ([] : (string * pending_univar) list) + let assert_univars uvs = + assert (List.for_all (fun (_name, v) -> not_generic v.univar) uvs) + + (* These are variables that will become univars when we're done with the + current type. Used to force free variables in method types to become + univars. + *) + let pre_univars = ref ([] : type_expr list) + + let reset () = + reset_global_level (); + type_variables := TyVarMap.empty + + let is_in_scope name = + TyVarMap.mem name !type_variables + + let add name v = + assert (not_generic v); + type_variables := TyVarMap.add name v !type_variables + + let narrow () = + (increase_global_level (), !type_variables) + + let widen (gl, tv) = + restore_global_level gl; + type_variables := tv + + let with_local_scope f = + let context = narrow () in + Fun.protect + f + ~finally:(fun () -> widen context) + + (* throws Not_found if the variable is not in scope *) + let lookup_global_type_variable name = + TyVarMap.find name !type_variables -type variable_context = int * type_expr TyVarMap.t + let get_in_scope_names () = + let add_name name _ l = + if name = "_" then l else Pprintast.tyvar_of_name name :: l + in + TyVarMap.fold add_name !type_variables [] + + (*****) + type poly_univars = (string * pending_univar) list + + let with_univars new_ones f = + assert_univars new_ones; + let old_univars = !univars in + univars := new_ones @ !univars; + Fun.protect + f + ~finally:(fun () -> univars := old_univars) + + let make_poly_univars vars = + let make name = { univar=newvar ~name (); associated = [] } in + List.map (fun name -> name, make name ) vars + + let promote_generics_to_univars promoted vars = + List.fold_left + (fun acc v -> + match get_desc v with + | Tvar name when get_level v = Btype.generic_level -> + set_type_desc v (Tunivar name); + v :: acc + | _ -> acc + ) + promoted vars + + let check_poly_univars env loc vars = + vars |> List.iter (fun (_, p) -> generalize p.univar); + let univars = + vars |> List.map (fun (name, {univar=ty1; _ }) -> + let v = Btype.proxy ty1 in + begin match get_desc v with + | Tvar name when get_level v = Btype.generic_level -> + set_type_desc v (Tunivar name) + | _ -> + raise (Error (loc, env, Cannot_quantify(name, v))) + end; + v) + in + (* Since we are promoting variables to univars in + {!promote_generics_to_univars}, even if a row variable is associated with + multiple univars we will promote it once, when checking the nearest + univar associated to this row variable. + *) + let promote_associated acc (_,v) = + let enclosed_rows = List.filter_map (!) v.associated in + promote_generics_to_univars acc enclosed_rows + in + List.fold_left promote_associated univars vars + + let instance_poly_univars env loc vars = + let vs = check_poly_univars env loc vars in + vs |> List.iter (fun v -> + match get_desc v with + | Tunivar name -> + set_type_desc v (Tvar name) + | _ -> assert false); + vs + + (*****) + let reset_locals ?univars:(uvs=[]) () = + assert_univars uvs; + univars := uvs; + used_variables := TyVarMap.empty + + let associate row_context p = + let add l x = if List.memq x l then l else x :: l in + p.associated <- List.fold_left add row_context p.associated + + (* throws Not_found if the variable is not in scope *) + let lookup_local ~row_context name = + try + let p = List.assoc name !univars in + associate row_context p; + p.univar + with Not_found -> + instance (fst (TyVarMap.find name !used_variables)) + (* This call to instance might be redundant; all variables + inserted into [used_variables] are non-generic, but some + might get generalized. *) + + let remember_used name v loc = + assert (not_generic v); + used_variables := TyVarMap.add name (v, loc) !used_variables + + + type flavor = Unification | Universal + type extensibility = Extensible | Fixed + type policy = { flavor : flavor; extensibility : extensibility } + + let fixed_policy = { flavor = Unification; extensibility = Fixed } + let extensible_policy = { flavor = Unification; extensibility = Extensible } + let univars_policy = { flavor = Universal; extensibility = Extensible } + + let add_pre_univar tv = function + | { flavor = Universal } -> + assert (not_generic tv); + pre_univars := tv :: !pre_univars + | _ -> () + + let collect_univars f = + pre_univars := []; + let result = f () in + let univs = promote_generics_to_univars [] !pre_univars in + result, univs + + let new_var ?name policy = + let tv = Ctype.newvar ?name () in + add_pre_univar tv policy; + tv + + let new_any_var loc env = function + | { extensibility = Fixed } -> raise(Error(loc, env, No_type_wildcards)) + | policy -> new_var policy + + let globalize_used_variables { flavor; extensibility } env = + let r = ref [] in + TyVarMap.iter + (fun name (ty, loc) -> + if flavor = Unification || is_in_scope name then + let v = new_global_var () in + let snap = Btype.snapshot () in + if try unify env v ty; true with _ -> Btype.backtrack snap; false + then try + r := (loc, v, lookup_global_type_variable name) :: !r + with Not_found -> + if extensibility = Fixed && Btype.is_Tvar ty then + raise(Error(loc, env, + Unbound_type_variable (Pprintast.tyvar_of_name name, + get_in_scope_names ()))); + let v2 = new_global_var () in + r := (loc, v, v2) :: !r; + add name v2) + !used_variables; + used_variables := TyVarMap.empty; + fun () -> + List.iter + (function (loc, t1, t2) -> + try unify env t1 t2 with Unify err -> + raise (Error(loc, env, Type_mismatch err))) + !r +end (* Support for first-class modules. *) let transl_modtype_longident = ref (fun _ -> assert false) let transl_modtype = ref (fun _ -> assert false) - -let create_package_mty fake loc env (p, l) = - let l = - List.sort - (fun (s1, _t1) (s2, _t2) -> - if s1.txt = s2.txt then - raise (Error (loc, env, Multiple_constraints_on_type s1.txt)); - compare s1.txt s2.txt) - l - in - l, - List.fold_left - (fun mty (s, t) -> - let d = {ptype_name = mkloc (Longident.last s.txt) s.loc; - ptype_params = []; - ptype_cstrs = []; - ptype_kind = Ptype_abstract; - ptype_private = Asttypes.Public; - ptype_manifest = if fake then None else Some t; - ptype_attributes = []; - ptype_loc = loc} in - Ast_helper.Mty.mk ~loc - (Pmty_with (mty, [ Pwith_type ({ txt = s.txt; loc }, d) ])) - ) - (Ast_helper.Mty.mk ~loc (Pmty_ident p)) +let check_package_with_type_constraints = ref (fun _ -> assert false) + +let sort_constraints_no_duplicates loc env l = + List.sort + (fun (s1, _t1) (s2, _t2) -> + if s1.txt = s2.txt then + raise (Error (loc, env, Multiple_constraints_on_type s1.txt)); + compare s1.txt s2.txt) l (* Translation of type expressions *) -let type_variables = ref (TyVarMap.empty : type_expr TyVarMap.t) -let univars = ref ([] : (string * type_expr) list) -let pre_univars = ref ([] : type_expr list) -let used_variables = ref (TyVarMap.empty : (type_expr * Location.t) TyVarMap.t) - -let reset_type_variables () = - reset_global_level (); - Ctype.reset_reified_var_counter (); - type_variables := TyVarMap.empty - -let narrow () = - (increase_global_level (), !type_variables) - -let widen (gl, tv) = - restore_global_level gl; - type_variables := tv +let generalize_ctyp typ = generalize typ.ctyp_type let strict_ident c = (c = '_' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z') @@ -117,12 +364,6 @@ let new_global_var ?name () = let newvar ?name () = newvar ?name:(validate_name name) () -let type_variable loc name = - try - TyVarMap.find name !type_variables - with Not_found -> - raise(Error(loc, Env.empty, Unbound_type_variable ("'" ^ name))) - let valid_tyvar_name name = name <> "" && name.[0] <> '_' @@ -135,15 +376,13 @@ let transl_type_param env styp = ctyp_loc = loc; ctyp_attributes = styp.ptyp_attributes; } | Ptyp_var name -> let ty = - try if not (valid_tyvar_name name) then raise (Error (loc, Env.empty, Invalid_variable_name ("'" ^ name))); - ignore (TyVarMap.find name !type_variables); - raise Already_bound - with Not_found -> + if TyVarEnv.is_in_scope name then + raise Already_bound; let v = new_global_var ~name () in - type_variables := TyVarMap.add name v !type_variables; - v + TyVarEnv.add name v; + v in { ctyp_desc = Ttyp_var name; ctyp_type = ty; ctyp_env = env; ctyp_loc = loc; ctyp_attributes = styp.ptyp_attributes; } @@ -155,44 +394,20 @@ let transl_type_param env styp = Builtin_attributes.warning_scope styp.ptyp_attributes (fun () -> transl_type_param env styp) +(* Forward declaration (set in Typemod.type_open) *) -let new_pre_univar ?name () = - let v = newvar ?name () in pre_univars := v :: !pre_univars; v - -type poly_univars = (string * type_expr) list -let make_poly_univars vars = - List.map (fun name -> name, newvar ~name ()) vars - -let check_poly_univars env loc vars = - vars |> List.iter (fun (_, v) -> generalize v); - vars |> List.map (fun (name, ty1) -> - let v = Btype.proxy ty1 in - begin match get_desc v with - | Tvar name when get_level v = Btype.generic_level -> - set_type_desc v (Tunivar name) - | _ -> - raise (Error (loc, env, Cannot_quantify(name, v))) - end; - v) - -let instance_poly_univars env loc vars = - let vs = check_poly_univars env loc vars in - vs |> List.iter (fun v -> - match get_desc v with - | Tunivar name -> - set_type_desc v (Tvar name) - | _ -> assert false); - vs - +let type_open : + (?used_slot:bool ref -> override_flag -> Env.t -> Location.t -> + Longident.t loc -> Path.t * Env.t) + ref = + ref (fun ?used_slot:_ _ -> assert false) -type policy = Fixed | Extensible | Univars - -let rec transl_type env policy styp = +let rec transl_type env ~policy ?(aliased=false) ~row_context styp = Msupport.with_saved_types ~warning_attribute:styp.ptyp_attributes ?save_part:None (fun () -> try - transl_type_aux env policy styp + transl_type_aux env ~policy ~aliased ~row_context styp with exn -> let ty = new_global_var () in Msupport.erroneous_type_register ty; @@ -205,7 +420,7 @@ let rec transl_type env policy styp = } ) -and transl_type_aux env policy styp = +and transl_type_aux env ~row_context ~aliased ~policy styp = let loc = styp.ptyp_loc in let ctyp ctyp_desc ctyp_type = { ctyp_desc; ctyp_type; ctyp_env = env; @@ -213,33 +428,24 @@ and transl_type_aux env policy styp = in match styp.ptyp_desc with Ptyp_any -> - let ty = - if policy = Univars then new_pre_univar () else - if policy = Fixed then - raise (Error (styp.ptyp_loc, env, Unbound_type_variable "_")) - else newvar () - in + let ty = TyVarEnv.new_any_var styp.ptyp_loc env policy in ctyp Ttyp_any ty | Ptyp_var name -> let ty = if not (valid_tyvar_name name) then raise (Error (styp.ptyp_loc, env, Invalid_variable_name ("'" ^ name))); begin try - instance (List.assoc name !univars) - with Not_found -> try - instance (fst (TyVarMap.find name !used_variables)) + TyVarEnv.lookup_local ~row_context:row_context name with Not_found -> - let v = - if policy = Univars then new_pre_univar ~name () else newvar ~name () - in - used_variables := TyVarMap.add name (v, styp.ptyp_loc) !used_variables; + let v = TyVarEnv.new_var ~name policy in + TyVarEnv.remember_used name v styp.ptyp_loc; v end in ctyp (Ttyp_var name) ty | Ptyp_arrow(l, st1, st2) -> - let cty1 = transl_type env policy st1 in - let cty2 = transl_type env policy st2 in + let cty1 = transl_type env ~policy ~row_context st1 in + let cty2 = transl_type env ~policy ~row_context st2 in let ty1 = cty1.ctyp_type in let ty1 = if Btype.is_optional l @@ -249,7 +455,7 @@ and transl_type_aux env policy styp = ctyp (Ttyp_arrow (l, cty1, cty2)) ty | Ptyp_tuple stl -> assert (List.length stl >= 2); - let ctys = List.map (transl_type env policy) stl in + let ctys = List.map (transl_type env ~policy ~row_context) stl in let ty = newty (Ttuple (List.map (fun ctyp -> ctyp.ctyp_type) ctys)) in ctyp (Ttyp_tuple ctys) ty | Ptyp_constr(lid, stl) -> @@ -264,7 +470,7 @@ and transl_type_aux env policy styp = raise(Error(styp.ptyp_loc, env, Type_arity_mismatch(lid.txt, decl.type_arity, List.length stl))); - let args = List.map (transl_type env policy) stl in + let args = List.map (transl_type env ~policy ~row_context) stl in let params = instance_list decl.type_params in let unify_param = match decl.type_manifest with @@ -283,45 +489,20 @@ and transl_type_aux env policy styp = newconstr path (List.map (fun ctyp -> ctyp.ctyp_type) args) in ctyp (Ttyp_constr (path, lid, args)) constr | Ptyp_object (fields, o) -> - let ty, fields = transl_fields env policy o fields in + let ty, fields = transl_fields env ~policy ~row_context o fields in ctyp (Ttyp_object (fields, o)) (newobj ty) | Ptyp_class(lid, stl) -> - let (path, decl, _is_variant) = - try - let path, decl = Env.find_type_by_name lid.txt env in - let rec check decl = - match decl.type_manifest with - None -> raise Not_found - | Some ty -> - match get_desc ty with - Tvariant row when Btype.static_row row -> () - | Tconstr (path, _, _) -> - check (Env.find_type path env) - | _ -> raise Not_found - in check decl; - Location.deprecated styp.ptyp_loc - "old syntax for polymorphic variant type"; - ignore(Env.lookup_type ~loc:lid.loc lid.txt env); - (path, decl,true) - with Not_found -> try - let lid2 = - match lid.txt with - Longident.Lident s -> Longident.Lident ("#" ^ s) - | Longident.Ldot(r, s) -> Longident.Ldot (r, "#" ^ s) - | Longident.Lapply(_, _) -> fatal_error "Typetexp.transl_type" - in - let path, decl = Env.find_type_by_name lid2 env in - ignore(Env.lookup_cltype ~loc:lid.loc lid.txt env); - (path, decl, false) - with Not_found -> - ignore (Env.lookup_cltype ~loc:lid.loc lid.txt env); assert false + let (path, decl) = + let path, decl = Env.lookup_cltype ~loc:lid.loc lid.txt env in + (path, decl.clty_hash_type) in if List.length stl <> decl.type_arity then raise(Error(styp.ptyp_loc, env, Type_arity_mismatch(lid.txt, decl.type_arity, List.length stl))); - let args = List.map (transl_type env policy) stl in - let params = instance_list decl.type_params in + let args = List.map (transl_type env ~policy ~row_context) stl in + let body = Option.get decl.type_manifest in + let (params, body) = instance_parameterized_type decl.type_params body in List.iter2 (fun (sty, cty) ty' -> try unify_var env ty' cty.ctyp_type with Unify err -> @@ -329,66 +510,47 @@ and transl_type_aux env policy styp = raise (Error(sty.ptyp_loc, env, Type_mismatch err)) ) (List.combine stl args) params; - let ty_args = List.map (fun ctyp -> ctyp.ctyp_type) args in - let ty = Ctype.expand_head env (newconstr path ty_args) in + let ty_args = List.map (fun ctyp -> ctyp.ctyp_type) args in + let ty = Ctype.apply ~use_current_level:true env params body ty_args in let ty = match get_desc ty with - Tvariant row -> - let fields = - List.map - (fun (l,f) -> l, - match row_field_repr f with - | Rpresent oty -> rf_either_of oty - | _ -> f) - (row_fields row) - in - (* NB: row is always non-static here; more is thus never Tnil *) - let more = - if policy = Univars then new_pre_univar () else newvar () in - let row = - create_row ~fields ~more - ~closed:true ~fixed:None ~name:(Some (path, ty_args)) in - newty (Tvariant row) - | Tobject (fi, _) -> - let _, tv = flatten_fields fi in - if policy = Univars then pre_univars := tv :: !pre_univars; - ty - | _ -> - assert false + | Tobject (fi, _) -> + let _, tv = flatten_fields fi in + TyVarEnv.add_pre_univar tv policy; + ty + | _ -> + assert false in ctyp (Ttyp_class (path, lid, args)) ty | Ptyp_alias(st, alias) -> let cty = try - let t = - try List.assoc alias !univars - with Not_found -> - instance (fst(TyVarMap.find alias !used_variables)) - in - let ty = transl_type env policy st in + let t = TyVarEnv.lookup_local ~row_context alias.txt in + let ty = transl_type env ~policy ~aliased:true ~row_context st in begin try unify_var env t ty.ctyp_type with Unify err -> let err = Errortrace.swap_unification_error err in - raise(Error(styp.ptyp_loc, env, Alias_type_mismatch err)) + raise(Error(alias.loc, env, Alias_type_mismatch err)) end; ty with Not_found -> - if !Clflags.principal then begin_def (); - let t = newvar () in - used_variables := - TyVarMap.add alias (t, styp.ptyp_loc) !used_variables; - let ty = transl_type env policy st in - begin try unify_var env t ty.ctyp_type with Unify err -> - let err = Errortrace.swap_unification_error err in - raise(Error(styp.ptyp_loc, env, Alias_type_mismatch err)) - end; - if !Clflags.principal then begin - end_def (); - generalize_structure t; - end; + let t, ty = + with_local_level_if_principal begin fun () -> + let t = newvar () in + (* Use the whole location, which is used by [Type_mismatch]. *) + TyVarEnv.remember_used alias.txt t styp.ptyp_loc; + let ty = transl_type env ~policy ~row_context st in + begin try unify_var env t ty.ctyp_type with Unify err -> + let err = Errortrace.swap_unification_error err in + raise(Error(alias.loc, env, Alias_type_mismatch err)) + end; + (t, ty) + end + ~post: (fun (t, _) -> generalize_structure t) + in let t = instance t in let px = Btype.proxy t in begin match get_desc px with - | Tvar None -> set_type_desc px (Tvar (Some alias)) - | Tunivar None -> set_type_desc px (Tunivar (Some alias)) + | Tvar None -> set_type_desc px (Tvar (Some alias.txt)) + | Tunivar None -> set_type_desc px (Tunivar (Some alias.txt)) | _ -> () end; { ty with ctyp_type = t } @@ -414,7 +576,7 @@ and transl_type_aux env policy styp = with Not_found -> Hashtbl.add hfields h (l,f) in - let add_field field = + let add_field row_context field = let rf_loc = field.prf_loc in let rf_attributes = field.prf_attributes in let rf_desc = match field.prf_desc with @@ -422,7 +584,7 @@ and transl_type_aux env policy styp = name := None; let tl = Builtin_attributes.warning_scope rf_attributes - (fun () -> List.map (transl_type env policy) stl) + (fun () -> List.map (transl_type env ~policy ~row_context) stl) in let f = match present with Some present when not (List.mem l.txt present) -> @@ -438,7 +600,7 @@ and transl_type_aux env policy styp = add_typed_field styp.ptyp_loc l.txt f; Ttag (l,c,tl) | Rinherit sty -> - let cty = transl_type env policy sty in + let cty = transl_type env ~policy ~row_context sty in let ty = cty.ctyp_type in let nm = match get_desc cty.ctyp_type with @@ -470,7 +632,11 @@ and transl_type_aux env policy styp = in { rf_desc; rf_loc; rf_attributes; } in - let tfields = List.map add_field fields in + let more_slot = ref None in + let row_context = + if aliased then row_context else more_slot :: row_context + in + let tfields = List.map (add_field row_context) fields in let fields = List.rev (Hashtbl.fold (fun _ p l -> p :: l) hfields []) in begin match present with None -> () | Some present -> @@ -485,48 +651,62 @@ and transl_type_aux env policy styp = in let more = if Btype.static_row (make_row (newvar ())) then newty Tnil else - if policy = Univars then new_pre_univar () else newvar () + TyVarEnv.new_var policy in + more_slot := Some more; let ty = newty (Tvariant (make_row more)) in ctyp (Ttyp_variant (tfields, closed, present)) ty | Ptyp_poly(vars, st) -> let vars = List.map (fun v -> v.txt) vars in - begin_def(); - let new_univars = make_poly_univars vars in - let old_univars = !univars in - univars := new_univars @ !univars; - let cty = transl_type env policy st in + let new_univars, cty = + with_local_level begin fun () -> + let new_univars = TyVarEnv.make_poly_univars vars in + let cty = TyVarEnv.with_univars new_univars begin fun () -> + transl_type env ~policy ~row_context st + end in + (new_univars, cty) + end + ~post:(fun (_,cty) -> generalize_ctyp cty) + in let ty = cty.ctyp_type in - univars := old_univars; - end_def(); - generalize ty; - let ty_list = check_poly_univars env styp.ptyp_loc new_univars in + let ty_list = TyVarEnv.check_poly_univars env styp.ptyp_loc new_univars in let ty_list = List.filter (fun v -> deep_occur v ty) ty_list in let ty' = Btype.newgenty (Tpoly(ty, ty_list)) in unify_var env (newvar()) ty'; ctyp (Ttyp_poly (vars, cty)) ty' | Ptyp_package (p, l) -> - let l, mty = create_package_mty true styp.ptyp_loc env (p, l) in - let z = narrow () in - let mty = !transl_modtype env mty in - widen z; - let ptys = List.map (fun (s, pty) -> - s, transl_type env policy pty - ) l in - let path = !transl_modtype_longident styp.ptyp_loc env p.txt in + let loc = styp.ptyp_loc in + let l = sort_constraints_no_duplicates loc env l in + let mty = Ast_helper.Mty.mk ~loc (Pmty_ident p) in + let mty = TyVarEnv.with_local_scope (fun () -> !transl_modtype env mty) in + let ptys = + List.map (fun (s, pty) -> s, transl_type env ~policy ~row_context pty) l + in + let mty = + if ptys <> [] then + !check_package_with_type_constraints loc env mty.mty_type ptys + else mty.mty_type + in + let path = !transl_modtype_longident loc env p.txt in let ty = newty (Tpackage (path, List.map (fun (s, cty) -> (s.txt, cty.ctyp_type)) ptys)) in ctyp (Ttyp_package { pack_path = path; - pack_type = mty.mty_type; + pack_type = mty; pack_fields = ptys; pack_txt = p; }) ty + | Ptyp_open (mod_ident, t) -> + let path, new_env = + !type_open Asttypes.Fresh env loc mod_ident + in + let cty = transl_type new_env ~policy ~row_context t in + ctyp (Ttyp_open (path, mod_ident, cty)) cty.ctyp_type | Ptyp_extension ext -> raise (Error_forward (Builtin_attributes.error_of_extension ext)) -and transl_fields env policy o fields = +and transl_fields env ~policy ~row_context o fields = let hfields = Hashtbl.create 17 in let add_typed_field loc l ty = try @@ -544,14 +724,15 @@ and transl_fields env policy o fields = | Otag (s, ty1) -> begin let ty1 = Builtin_attributes.warning_scope of_attributes - (fun () -> transl_type env policy (Ast_helper.Typ.force_poly ty1)) + (fun () -> transl_type env ~policy ~row_context + (Ast_helper.Typ.force_poly ty1)) in let field = OTtag (s, ty1) in add_typed_field ty1.ctyp_loc s.txt ty1.ctyp_type; field end | Oinherit sty -> begin - let cty = transl_type env policy sty in + let cty = transl_type env ~policy ~row_context sty in let nm = match get_desc cty.ctyp_type with Tconstr(p, _, _) -> Some p @@ -583,14 +764,16 @@ and transl_fields env policy o fields = let object_fields = List.map add_field fields in let fields = Hashtbl.fold (fun s ty l -> (s, ty) :: l) hfields [] in let ty_init = - match o, policy with - | Closed, _ -> newty Tnil - | Open, Univars -> new_pre_univar () - | Open, _ -> newvar () in + match o with + | Closed -> newty Tnil + | Open -> TyVarEnv.new_var policy + in let ty = List.fold_left (fun ty (s, ty') -> newty (Tfield (s, field_public, ty', ty))) ty_init fields in ty, object_fields +let transl_type env policy styp = + transl_type env ~policy ~row_context:[] styp (* Make the rows "fixed" in this type, to make universal check easier *) let rec make_fixed_univars ty = @@ -620,133 +803,101 @@ let make_fixed_univars ty = make_fixed_univars ty; Btype.unmark_type ty -let create_package_mty = create_package_mty false - -let globalize_used_variables env fixed = - let r = ref [] in - TyVarMap.iter - (fun name (ty, loc) -> - let v = new_global_var () in - let snap = Btype.snapshot () in - if try unify env v ty; true with _ -> Btype.backtrack snap; false - then try - r := (loc, v, TyVarMap.find name !type_variables) :: !r - with Not_found -> - if fixed && Btype.is_Tvar ty then - raise(Error(loc, env, Unbound_type_variable ("'"^name))); - let v2 = new_global_var () in - r := (loc, v, v2) :: !r; - type_variables := TyVarMap.add name v2 !type_variables) - !used_variables; - used_variables := TyVarMap.empty; - fun () -> - List.iter - (function (loc, t1, t2) -> - try unify env t1 t2 with Unify err -> - raise (Error(loc, env, Type_mismatch err))) - !r - -let transl_simple_type env ?univars:(uvs=[]) fixed styp = - univars := uvs; used_variables := TyVarMap.empty; - let typ = transl_type env (if fixed then Fixed else Extensible) styp in - globalize_used_variables env fixed (); +let transl_simple_type env ?univars ~closed styp = + TyVarEnv.reset_locals ?univars (); + let policy = TyVarEnv.(if closed then fixed_policy else extensible_policy) in + let typ = transl_type env policy styp in + TyVarEnv.globalize_used_variables policy env (); make_fixed_univars typ.ctyp_type; typ let transl_simple_type_univars env styp = - univars := []; used_variables := TyVarMap.empty; pre_univars := []; - begin_def (); - let typ = transl_type env Univars styp in - (* Only keep already global variables in used_variables *) - let new_variables = !used_variables in - used_variables := TyVarMap.empty; - TyVarMap.iter - (fun name p -> - if TyVarMap.mem name !type_variables then - used_variables := TyVarMap.add name p !used_variables) - new_variables; - globalize_used_variables env false (); - end_def (); - generalize typ.ctyp_type; - let univs = - List.fold_left - (fun acc v -> - match get_desc v with - Tvar name when get_level v = Btype.generic_level -> - set_type_desc v (Tunivar name); v :: acc - | _ -> acc) - [] !pre_univars - in + TyVarEnv.reset_locals (); + let typ, univs = + TyVarEnv.collect_univars begin fun () -> + with_local_level ~post:generalize_ctyp begin fun () -> + let policy = TyVarEnv.univars_policy in + let typ = transl_type env policy styp in + TyVarEnv.globalize_used_variables policy env (); + typ + end + end in make_fixed_univars typ.ctyp_type; { typ with ctyp_type = instance (Btype.newgenty (Tpoly (typ.ctyp_type, univs))) } let transl_simple_type_delayed env styp = - univars := []; used_variables := TyVarMap.empty; - begin_def (); - let typ = transl_type env Extensible styp in - end_def (); - make_fixed_univars typ.ctyp_type; - (* This brings the used variables to the global level, but doesn't link them - to their other occurrences just yet. This will be done when [force] is - called. *) - let force = globalize_used_variables env false in - (* Generalizes everything except the variables that were just globalized. *) - generalize typ.ctyp_type; + TyVarEnv.reset_locals (); + let typ, force = + with_local_level begin fun () -> + let policy = TyVarEnv.extensible_policy in + let typ = transl_type env policy styp in + make_fixed_univars typ.ctyp_type; + (* This brings the used variables to the global level, but doesn't link + them to their other occurrences just yet. This will be done when + [force] is called. *) + let force = TyVarEnv.globalize_used_variables policy env in + (typ, force) + end + (* Generalize everything except the variables that were just globalized. *) + ~post:(fun (typ,_) -> generalize_ctyp typ) + in (typ, instance typ.ctyp_type, force) let transl_type_scheme env styp = - reset_type_variables(); match styp.ptyp_desc with | Ptyp_poly (vars, st) -> - begin_def(); let vars = List.map (fun v -> v.txt) vars in - let univars = make_poly_univars vars in - let typ = transl_simple_type env ~univars true st in - end_def(); - generalize typ.ctyp_type; - let _ = instance_poly_univars env styp.ptyp_loc univars in + let univars, typ = + with_local_level begin fun () -> + TyVarEnv.reset (); + let univars = TyVarEnv.make_poly_univars vars in + let typ = transl_simple_type env ~univars ~closed:true st in + (univars, typ) + end + ~post:(fun (_,typ) -> generalize_ctyp typ) + in + let _ = TyVarEnv.instance_poly_univars env styp.ptyp_loc univars in { ctyp_desc = Ttyp_poly (vars, typ); ctyp_type = typ.ctyp_type; ctyp_env = env; ctyp_loc = styp.ptyp_loc; ctyp_attributes = styp.ptyp_attributes } | _ -> - begin_def(); - let typ = transl_simple_type env false styp in - end_def(); - generalize typ.ctyp_type; - typ + with_local_level + (fun () -> TyVarEnv.reset (); transl_simple_type env ~closed:false styp) + ~post:generalize_ctyp (* Error report *) open Format open Printtyp +module Style = Misc.Style +let pp_tag ppf t = Format.fprintf ppf "`%s" t + let report_error env ppf = function - | Unbound_type_variable name -> - let add_name name _ l = if name = "_" then l else ("'" ^ name) :: l in - let names = TyVarMap.fold add_name !type_variables [] in - fprintf ppf "The type variable %s is unbound in this type declaration.@ %a" - name - did_you_mean (fun () -> Misc.spellcheck names name ) + | Unbound_type_variable (name, in_scope_names) -> + fprintf ppf "The type variable %a is unbound in this type declaration.@ %a" + Style.inline_code name + did_you_mean (fun () -> Misc.spellcheck in_scope_names name ) + | No_type_wildcards -> + fprintf ppf "A type wildcard %a is not allowed in this type declaration." + Style.inline_code "_" | Undefined_type_constructor p -> fprintf ppf "The type constructor@ %a@ is not yet completely defined" - path p + (Style.as_inline_code path) p | Type_arity_mismatch(lid, expected, provided) -> fprintf ppf "@[The type constructor %a@ expects %i argument(s),@ \ but is here applied to %i argument(s)@]" - longident lid expected provided + (Style.as_inline_code longident) lid expected provided | Bound_type_variable name -> - fprintf ppf "Already bound type parameter %a" Pprintast.tyvar name + fprintf ppf "Already bound type parameter %a" + (Style.as_inline_code Pprintast.tyvar) name | Recursive_type -> fprintf ppf "This type is recursive" - | Unbound_row_variable lid -> - (* we don't use "spellcheck" here: this error is not raised - anywhere so it's unclear how it should be handled *) - fprintf ppf "Unbound row variable in #%a" longident lid | Type_mismatch trace -> Printtyp.report_unification_error ppf Env.empty trace (function ppf -> @@ -760,27 +911,33 @@ let report_error env ppf = function (function ppf -> fprintf ppf "but is used as an instance of type") | Present_has_conjunction l -> - fprintf ppf "The present constructor %s has a conjunctive type" l + fprintf ppf "The present constructor %a has a conjunctive type" + Style.inline_code l | Present_has_no_type l -> fprintf ppf - "@[@[The constructor %s is missing from the upper bound@ \ - (between '<'@ and '>')@ of this polymorphic variant@ \ - but is present in@ its lower bound (after '>').@]@,\ - @[Hint: Either add `%s in the upper bound,@ \ + "@[@[The constructor %a is missing from the upper bound@ \ + (between %a@ and %a)@ of this polymorphic variant@ \ + but is present in@ its lower bound (after %a).@]@,\ + @[@{Hint@}: Either add %a in the upper bound,@ \ or remove it@ from the lower bound.@]@]" - l l + (Style.as_inline_code pp_tag) l + Style.inline_code "<" + Style.inline_code ">" + Style.inline_code ">" + (Style.as_inline_code pp_tag) l | Constructor_mismatch (ty, ty') -> + let pp_type ppf ty = Style.as_inline_code !Oprint.out_type ppf ty in wrap_printing_env ~error:true env (fun () -> Printtyp.prepare_for_printing [ty; ty']; fprintf ppf "@[%s %a@ %s@ %a@]" "This variant type contains a constructor" - !Oprint.out_type (tree_of_typexp Type ty) + pp_type (tree_of_typexp Type ty) "which should be" - !Oprint.out_type (tree_of_typexp Type ty')) + pp_type (tree_of_typexp Type ty')) | Not_a_variant ty -> fprintf ppf "@[The type %a@ does not expand to a polymorphic variant type@]" - Printtyp.type_expr ty; + (Style.as_inline_code Printtyp.type_expr) ty; begin match get_desc ty with | Tvar (Some s) -> (* PR#7012: help the user that wrote 'Foo instead of `Foo *) @@ -789,36 +946,43 @@ let report_error env ppf = function end | Variant_tags (lab1, lab2) -> fprintf ppf - "@[Variant tags `%s@ and `%s have the same hash value.@ %s@]" - lab1 lab2 "Change one of them." + "@[Variant tags %a@ and %a have the same hash value.@ %s@]" + (Style.as_inline_code pp_tag) lab1 + (Style.as_inline_code pp_tag) lab2 + "Change one of them." | Invalid_variable_name name -> - fprintf ppf "The type variable name %s is not allowed in programs" name + fprintf ppf "The type variable name %a is not allowed in programs" + Style.inline_code name | Cannot_quantify (name, v) -> fprintf ppf "@[The universal type variable %a cannot be generalized:@ " - Pprintast.tyvar name; + (Style.as_inline_code Pprintast.tyvar) name; if Btype.is_Tvar v then fprintf ppf "it escapes its scope" else if Btype.is_Tunivar v then fprintf ppf "it is already bound to another variable" else - fprintf ppf "it is bound to@ %a" Printtyp.type_expr v; + fprintf ppf "it is bound to@ %a" + (Style.as_inline_code Printtyp.type_expr) v; fprintf ppf ".@]"; | Multiple_constraints_on_type s -> - fprintf ppf "Multiple constraints for type %a" longident s + fprintf ppf "Multiple constraints for type %a" + (Style.as_inline_code longident) s | Method_mismatch (l, ty, ty') -> wrap_printing_env ~error:true env (fun () -> - fprintf ppf "@[Method '%s' has type %a,@ which should be %a@]" - l Printtyp.type_expr ty Printtyp.type_expr ty') + fprintf ppf "@[Method %a has type %a,@ which should be %a@]" + Style.inline_code l + (Style.as_inline_code Printtyp.type_expr) ty + (Style.as_inline_code Printtyp.type_expr) ty') | Opened_object nm -> fprintf ppf "Illegal open object type%a" (fun ppf -> function - Some p -> fprintf ppf "@ %a" path p + Some p -> fprintf ppf "@ %a" (Style.as_inline_code path) p | None -> fprintf ppf "") nm | Not_an_object ty -> fprintf ppf "@[The type %a@ is not an object type@]" - Printtyp.type_expr ty + (Style.as_inline_code Printtyp.type_expr) ty let () = Location.register_error_of_exn diff --git a/src/ocaml/typing/typetexp.mli b/src/ocaml/typing/typetexp.mli index c264ab599a..34243b1d42 100644 --- a/src/ocaml/typing/typetexp.mli +++ b/src/ocaml/typing/typetexp.mli @@ -17,24 +17,45 @@ open Types -val valid_tyvar_name : string -> bool +module TyVarEnv : sig + (* this is just the subset of [TyVarEnv] that is needed outside + of [Typetexp]. See the ml file for more. *) + + val reset : unit -> unit + (** removes all type variables from scope *) + + val with_local_scope : (unit -> 'a) -> 'a + (** Evaluate in a narrowed type-variable scope *) + + type poly_univars + val make_poly_univars : string list -> poly_univars + (** remember that a list of strings connotes univars; this must + always be paired with a [check_poly_univars]. *) + + val check_poly_univars : + Env.t -> Location.t -> poly_univars -> type_expr list + (** Verify that the given univars are universally quantified, + and return the list of variables. The type in which the + univars are used must be generalised *) -type poly_univars -val make_poly_univars : string list -> poly_univars - (* Create a set of univars with given names *) -val check_poly_univars : - Env.t -> Location.t -> poly_univars -> type_expr list - (* Verify that the given univars are universally quantified, - and return the list of variables. The type in which the - univars are used must be generalised *) -val instance_poly_univars : - Env.t -> Location.t -> poly_univars -> type_expr list - (* Same as [check_poly_univars], but instantiates the resulting - type scheme (i.e. variables become Tvar rather than Tunivar) *) + val instance_poly_univars : + Env.t -> Location.t -> poly_univars -> type_expr list + (** Same as [check_poly_univars], but instantiates the resulting + type scheme (i.e. variables become Tvar rather than Tunivar) *) + +end + +(* Forward declaration, to be filled in by Typemod.type_open *) +val type_open: + (?used_slot:bool ref -> Asttypes.override_flag -> Env.t -> Location.t -> + Longident.t Asttypes.loc -> Path.t * Env.t) + ref + +val valid_tyvar_name : string -> bool val transl_simple_type: - Env.t -> ?univars:poly_univars -> bool -> Parsetree.core_type - -> Typedtree.core_type + Env.t -> ?univars:TyVarEnv.poly_univars -> closed:bool + -> Parsetree.core_type -> Typedtree.core_type val transl_simple_type_univars: Env.t -> Parsetree.core_type -> Typedtree.core_type val transl_simple_type_delayed @@ -46,24 +67,18 @@ val transl_simple_type_delayed function that binds the type variable. *) val transl_type_scheme: Env.t -> Parsetree.core_type -> Typedtree.core_type -val reset_type_variables: unit -> unit -val type_variable: Location.t -> string -> type_expr val transl_type_param: Env.t -> Parsetree.core_type -> Typedtree.core_type -type variable_context -val narrow: unit -> variable_context -val widen: variable_context -> unit - exception Already_bound type error = - Unbound_type_variable of string + | Unbound_type_variable of string * string list + | No_type_wildcards | Undefined_type_constructor of Path.t | Type_arity_mismatch of Longident.t * int * int | Bound_type_variable of string | Recursive_type - | Unbound_row_variable of Longident.t | Type_mismatch of Errortrace.unification_error | Alias_type_mismatch of Errortrace.unification_error | Present_has_conjunction of string @@ -87,7 +102,7 @@ val transl_modtype_longident: (* from Typemod *) (Location.t -> Env.t -> Longident.t -> Path.t) ref val transl_modtype: (* from Typemod *) (Env.t -> Parsetree.module_type -> Typedtree.module_type) ref -val create_package_mty: - Location.t -> Env.t -> Parsetree.package_type -> - (Longident.t Asttypes.loc * Parsetree.core_type) list * - Parsetree.module_type +val check_package_with_type_constraints: (* from Typemod *) + (Location.t -> Env.t -> Types.module_type -> + (Longident.t Asttypes.loc * Typedtree.core_type) list -> + Types.module_type) ref diff --git a/src/ocaml/typing/untypeast.ml b/src/ocaml/typing/untypeast.ml index a3fbeaf9d1..00a8ab1428 100644 --- a/src/ocaml/typing/untypeast.ml +++ b/src/ocaml/typing/untypeast.ml @@ -13,7 +13,9 @@ (* *) (**************************************************************************) -open Longident +[@@@ocaml.warning "-60"] module Str = Ast_helper.Str (* For ocamldep *) +[@@@ocaml.warning "+60"] + open Asttypes open Parsetree open Ast_helper @@ -78,11 +80,6 @@ open T (* Some notes: - * For Pexp_function, we cannot go back to the exact original version - when there is a default argument, because the default argument is - translated in the typer. The code, if printed, will not be parsable because - new generated identifiers are not correct. - * For Pexp_apply, it is unclear whether arguments are reordered, especially when there are optional arguments. @@ -97,21 +94,14 @@ let string_is_prefix sub str = let rec lident_of_path = function | Path.Pident id -> Longident.Lident (Ident.name id) - | Path.Pdot (p, s) -> Longident.Ldot (lident_of_path p, s) | Path.Papply (p1, p2) -> Longident.Lapply (lident_of_path p1, lident_of_path p2) + | Path.Pdot (p, s) | Path.Pextra_ty (p, Pcstr_ty s) -> + Longident.Ldot (lident_of_path p, s) + | Path.Pextra_ty (p, _) -> lident_of_path p let map_loc sub {loc; txt} = {loc = sub.location sub loc; txt} -(** Try a name [$name$0], check if it's free, if not, increment and repeat. *) -let fresh_name s env = - let rec aux i = - let name = s ^ Int.to_string i in - if Env.bound_value name env then aux (i+1) - else name - in - aux 0 - (** Extract the [n] patterns from the case of a letop *) let rec extract_letop_patterns n pat = if n = 0 then pat, [] @@ -298,7 +288,8 @@ let pattern : type k . _ -> k T.general_pattern -> _ = fun sub pat -> match pat with { pat_extra=[Tpat_unpack, loc, _attrs]; pat_desc = Tpat_any; _ } -> Ppat_unpack { txt = None; loc } - | { pat_extra=[Tpat_unpack, _, _attrs]; pat_desc = Tpat_var (_,name); _ } -> + | { pat_extra=[Tpat_unpack, _, _attrs]; + pat_desc = Tpat_var (_,name, _); _ } -> Ppat_unpack { name with txt = Some name.txt } | { pat_extra=[Tpat_type (_path, lid), _, _attrs]; _ } -> Ppat_type (map_loc sub lid) @@ -308,7 +299,7 @@ let pattern : type k . _ -> k T.general_pattern -> _ = fun sub pat -> | _ -> match pat.pat_desc with Tpat_any -> Ppat_any - | Tpat_var (id, name) -> + | Tpat_var (id, name, _) -> begin match (Ident.name id).[0] with 'A'..'Z' -> @@ -321,11 +312,11 @@ let pattern : type k . _ -> k T.general_pattern -> _ = fun sub pat -> The compiler transforms (x:t) into (_ as x : t). This avoids transforming a warning 27 into a 26. *) - | Tpat_alias ({pat_desc = Tpat_any; pat_loc}, _id, name) + | Tpat_alias ({pat_desc = Tpat_any; pat_loc}, _id, name, _) when pat_loc = pat.pat_loc -> Ppat_var name - | Tpat_alias (pat, _id, name) -> + | Tpat_alias (pat, _id, name, _) -> Ppat_alias (sub.pat sub pat, name) | Tpat_constant cst -> Ppat_constant (constant cst) | Tpat_tuple list -> @@ -379,7 +370,7 @@ let exp_extra sub (extra, loc, attrs) sexp = Pexp_constraint (sexp, sub.typ sub cty) | Texp_poly cto -> Pexp_poly (sexp, Option.map (sub.typ sub) cto) | Texp_newtype s -> Pexp_newtype (mkloc s loc, sexp) - | Texp_newtype' (_id, label_loc) -> Pexp_newtype (label_loc, sexp) + | Texp_newtype' (_id, label_loc, _) -> Pexp_newtype (label_loc, sexp) in Exp.mk ~loc ~attrs desc @@ -408,22 +399,52 @@ let expression sub exp = Pexp_let (rec_flag, List.map (sub.value_binding sub) list, sub.expr sub exp) - - (* Pexp_function can't have a label, so we split in 3 cases. *) - (* One case, no guard: It's a fun. *) - | Texp_function { arg_label; cases = [{c_lhs=p; c_guard=None; c_rhs=e}]; - _ } -> - Pexp_fun (arg_label, None, sub.pat sub p, sub.expr sub e) - (* No label: it's a function. *) - | Texp_function { arg_label = Nolabel; cases; _; } -> - Pexp_function (List.map (sub.case sub) cases) - (* Mix of both, we generate `fun ~label:$name$ -> match $name$ with ...` *) - | Texp_function { arg_label = Labelled s | Optional s as label; cases; - _ } -> - let name = fresh_name s exp.exp_env in - Pexp_fun (label, None, Pat.var ~loc {loc;txt = name }, - Exp.match_ ~loc (Exp.ident ~loc {loc;txt= Lident name}) - (List.map (sub.case sub) cases)) + | Texp_function (params, body) -> + let body, constraint_ = + match body with + | Tfunction_body body -> + (* Unlike function cases, the [exp_extra] is placed on the body + itself. *) + Pfunction_body (sub.expr sub body), None + | Tfunction_cases { cases; loc; exp_extra; attributes; _ } -> + let cases = List.map (sub.case sub) cases in + let constraint_ = + match exp_extra with + | Some (Texp_coerce (ty1, ty2)) -> + Some + (Pcoerce (Option.map (sub.typ sub) ty1, sub.typ sub ty2)) + | Some (Texp_constraint ty) -> + Some (Pconstraint (sub.typ sub ty)) + | Some (Texp_poly _ | Texp_newtype _ | Texp_newtype' _) + | None -> None + in + Pfunction_cases (cases, loc, attributes), constraint_ + in + let params = + List.concat_map + (fun fp -> + let pat, default_arg = + match fp.fp_kind with + | Tparam_pat pat -> pat, None + | Tparam_optional_default (pat, expr) -> pat, Some expr + in + let pat = sub.pat sub pat in + let default_arg = Option.map (sub.expr sub) default_arg in + let newtypes = + List.map + (fun x -> + { pparam_desc = Pparam_newtype x; + pparam_loc = x.loc; + }) + fp.fp_newtypes + in + let pparam_desc = + Pparam_val (fp.fp_arg_label, default_arg, pat) + in + { pparam_desc; pparam_loc = fp.fp_loc } :: newtypes) + params + in + Pexp_function (params, constraint_, body) | Texp_apply (exp, list) -> Pexp_apply (sub.expr sub exp, List.fold_right (fun (label, expo) list -> @@ -494,7 +515,7 @@ let expression sub exp = | Texp_letexception (ext, exp) -> Pexp_letexception (sub.extension_constructor sub ext, sub.expr sub exp) - | Texp_assert exp -> Pexp_assert (sub.expr sub exp) + | Texp_assert (exp, _) -> Pexp_assert (sub.expr sub exp) | Texp_lazy exp -> Pexp_lazy (sub.expr sub exp) | Texp_object (cl, _) -> Pexp_object (sub.class_structure sub cl) @@ -672,7 +693,10 @@ let module_expr (sub : mapper) mexpr = Pmod_functor (functor_parameter sub arg, sub.module_expr sub mexpr) | Tmod_apply (mexp1, mexp2, _) -> - Pmod_apply (sub.module_expr sub mexp1, sub.module_expr sub mexp2) + Pmod_apply (sub.module_expr sub mexp1, + sub.module_expr sub mexp2) + | Tmod_apply_unit mexp1 -> + Pmod_apply_unit (sub.module_expr sub mexp1) | Tmod_constraint (mexpr, _, Tmodtype_explicit mtype, _) -> Pmod_constraint (sub.module_expr sub mexpr, sub.module_type sub mtype) @@ -784,12 +808,13 @@ let core_type sub ct = let list = List.map (fun v -> mkloc v loc) list in Ptyp_poly (list, sub.typ sub ct) | Ttyp_package pack -> Ptyp_package (sub.package_type sub pack) + | Ttyp_open (_path, mod_ident, t) -> Ptyp_open (mod_ident, sub.typ sub t) in Typ.mk ~loc ~attrs desc let class_structure sub cs = let rec remove_self = function - | { pat_desc = Tpat_alias (p, id, _s) } + | { pat_desc = Tpat_alias (p, id, _s, _) } when string_is_prefix "selfpat-" (Ident.name id) -> remove_self p | p -> p @@ -819,10 +844,25 @@ let object_field sub {of_loc; of_desc; of_attributes;} = Of.mk ~loc ~attrs desc and is_self_pat = function - | { pat_desc = Tpat_alias(_pat, id, _) } -> + | { pat_desc = Tpat_alias(_pat, id, _, _) } -> string_is_prefix "self-" (Ident.name id) | _ -> false +(* [Typeclass] adds a [self] parameter to initializers and methods that isn't + present in the source program. +*) +let remove_fun_self exp = + match exp with + | { exp_desc = + Texp_function + ({fp_arg_label = Nolabel; fp_kind = Tparam_pat pat} :: params, body) + } + when is_self_pat pat -> + (match params, body with + | [], Tfunction_body body -> body + | _, _ -> { exp with exp_desc = Texp_function (params, body) }) + | e -> e + let class_field sub cf = let loc = sub.location sub cf.cf_loc in let attrs = sub.attributes sub cf.cf_attributes in @@ -839,21 +879,9 @@ let class_field sub cf = | Tcf_method (lab, priv, Tcfk_virtual cty) -> Pcf_method (lab, priv, Cfk_virtual (sub.typ sub cty)) | Tcf_method (lab, priv, Tcfk_concrete (o, exp)) -> - let remove_fun_self = function - | { exp_desc = - Texp_function { arg_label = Nolabel; cases = [case]; _ } } - when is_self_pat case.c_lhs && case.c_guard = None -> case.c_rhs - | e -> e - in let exp = remove_fun_self exp in Pcf_method (lab, priv, Cfk_concrete (o, sub.expr sub exp)) | Tcf_initializer exp -> - let remove_fun_self = function - | { exp_desc = - Texp_function { arg_label = Nolabel; cases = [case]; _ } } - when is_self_pat case.c_lhs && case.c_guard = None -> case.c_rhs - | e -> e - in let exp = remove_fun_self exp in Pcf_initializer (sub.expr sub exp) | Tcf_attribute x -> Pcf_attribute x diff --git a/src/ocaml/typing/value_rec_check.ml b/src/ocaml/typing/value_rec_check.ml new file mode 100644 index 0000000000..eb741e744a --- /dev/null +++ b/src/ocaml/typing/value_rec_check.ml @@ -0,0 +1,1421 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Jeremy Yallop, University of Cambridge *) +(* Gabriel Scherer, Project Parsifal, INRIA Saclay *) +(* Alban Reynaud, ENS Lyon *) +(* *) +(* Copyright 2017 Jeremy Yallop *) +(* Copyright 2018 Alban Reynaud *) +(* Copyright 2018 INRIA *) +(* *) +(* All rights reserved. This file is distributed under the terms of *) +(* the GNU Lesser General Public License version 2.1, with the *) +(* special exception on linking described in the file LICENSE. *) +(* *) +(**************************************************************************) + +(** Static checking of recursive declarations, as described in + + A practical mode system for recursive definitions + Alban Reynaud, Gabriel Scherer and Jeremy Yallop + POPL 2021 + +Some recursive definitions are meaningful +{[ + let rec factorial = function 0 -> 1 | n -> n * factorial (n - 1) + let rec infinite_list = 0 :: infinite_list +]} +but some other are meaningless +{[ + let rec x = x + let rec x = x+1 +]} + +Intuitively, a recursive definition makes sense when the body of the +definition can be evaluated without fully knowing what the recursive +name is yet. + +In the [factorial] example, the name [factorial] refers to a function, +evaluating the function definition [function ...] can be done +immediately and will not force a recursive call to [factorial] -- this +will only happen later, when [factorial] is called with an argument. + +In the [infinite_list] example, we can evaluate [0 :: infinite_list] +without knowing the full content of [infinite_list], but with just its +address. This is a case of productive/guarded recursion. + +On the contrary, [let rec x = x] is unguarded recursion (the meaning +is undetermined), and [let rec x = x+1] would need the value of [x] +while evaluating its definition [x+1]. + +This file implements a static check to decide which definitions are +known to be meaningful, and which may be meaningless. In the general +case, we handle a set of mutually-recursive definitions +{[ +let rec x1 = e1 +and x2 = e2 +... +and xn = en +]} + + +Our check (see function [is_valid_recursive_expression] is defined +using two criteria: + +Usage of recursive variables: how does each of the [e1 .. en] use the + recursive variables [x1 .. xn]? + +Static or dynamic size: for which of the [ei] can we compute the + in-memory size of the value without evaluating [ei] (so that we can + pre-allocate it, and thus know its final address before evaluation). + +The "static or dynamic size" is decided by the classify_* functions below. + +The "variable usage" question is decided by a static analysis looking +very much like a type system. The idea is to assign "access modes" to +variables, where an "access mode" [m] is defined as either + + m ::= Ignore (* the value is not used at all *) + | Delay (* the value is not needed at definition time *) + | Guard (* the value is stored under a data constructor *) + | Return (* the value result is directly returned *) + | Dereference (* full access and inspection of the value *) + +The access modes of an expression [e] are represented by a "context" +[G], which is simply a mapping from variables (the variables used in +[e]) to access modes. + +The core notion of the static check is a type-system-like judgment of +the form [G |- e : m], which can be interpreted as meaning either of: + +- If we are allowed to use the variables of [e] at the modes in [G] + (but not more), then it is safe to use [e] at the mode [m]. + +- If we want to use [e] at the mode [m], then its variables are + used at the modes in [G]. + +In practice, for a given expression [e], our implementation takes the +desired mode of use [m] as *input*, and returns a context [G] as +*output*, which is (uniquely determined as) the most permissive choice +of modes [G] for the variables of [e] such that [G |- e : m] holds. +*) + +open Asttypes +open Typedtree +open Types + +(** {1 Static or dynamic size} *) + +type sd = Value_rec_types.recursive_binding_kind + +let is_ref : Types.value_description -> bool = function + | { Types.val_kind = + Types.Val_prim { Primitive.prim_name = "%makemutable"; + prim_arity = 1 } } -> + true + | _ -> false + +(* See the note on abstracted arguments in the documentation for + Typedtree.Texp_apply *) +let is_abstracted_arg : arg_label * expression option -> bool = function + | (_, None) -> true + | (_, Some _) -> false + +let classify_expression : Typedtree.expression -> sd = + (* We need to keep track of the size of expressions + bound by local declarations, to be able to predict + the size of variables. Compare: + + let rec r = + let y = fun () -> r () + in y + + and + + let rec r = + let y = if Random.bool () then ignore else fun () -> r () + in y + + In both cases the final address of `r` must be known before `y` is compiled, + and this is only possible if `r` has a statically-known size. + + The first definition can be allowed (`y` has a statically-known + size) but the second one is unsound (`y` has no statically-known size). + *) + let rec classify_expression env e : sd = + match e.exp_desc with + (* binding and variable cases *) + | Texp_let (rec_flag, vb, e) -> + let env = classify_value_bindings rec_flag env vb in + classify_expression env e + | Texp_letmodule (Some mid, _, _, mexp, e) -> + (* Note on module presence: + For absent modules (i.e. module aliases), the module being bound + does not have a physical representation, but its size can still be + derived from the alias itself, so we can re-use the same code as + for modules that are present. *) + let size = classify_module_expression env mexp in + let env = Ident.add mid size env in + classify_expression env e + | Texp_ident (path, _, _) -> + classify_path env path + + (* non-binding cases *) + | Texp_open (_, e) + | Texp_letmodule (None, _, _, _, e) + | Texp_sequence (_, e) + | Texp_letexception (_, e) -> + classify_expression env e + + | Texp_construct (_, {cstr_tag = Cstr_unboxed}, [e]) -> + classify_expression env e + | Texp_construct _ -> + Static + + | Texp_record { representation = Record_unboxed _; + fields = [| _, Overridden (_,e) |] } -> + classify_expression env e + | Texp_record _ -> + Static + + | Texp_variant _ + | Texp_tuple _ + | Texp_extension_constructor _ + | Texp_constant _ -> + Static + + | Texp_for _ + | Texp_setfield _ + | Texp_while _ + | Texp_setinstvar _ -> + (* Unit-returning expressions *) + Static + + | Texp_unreachable -> + Static + + | Texp_apply ({exp_desc = Texp_ident (_, _, vd)}, _) + when is_ref vd -> + Static + | Texp_apply (_,args) + when List.exists is_abstracted_arg args -> + Static + | Texp_apply _ -> + Dynamic + + | Texp_array _ -> + Static + | Texp_pack mexp -> + classify_module_expression env mexp + | Texp_function _ -> + Static + | Texp_lazy e -> + (* The code below was copied (in part) from translcore.ml *) + begin match Typeopt.classify_lazy_argument e with + | `Constant_or_function -> + (* A constant expr (of type <> float if [Config.flat_float_array] is + true) gets compiled as itself. *) + classify_expression env e + | `Float_that_cannot_be_shortcut + | `Identifier `Forward_value -> + (* Forward blocks *) + Static + | `Identifier `Other -> + classify_expression env e + | `Other -> + (* other cases compile to a lazy block holding a function *) + Static + end + + | Texp_new _ + | Texp_instvar _ + | Texp_object _ + | Texp_match _ + | Texp_ifthenelse _ + | Texp_send _ + | Texp_field _ + | Texp_assert _ + | Texp_try _ + | Texp_override _ + | Texp_letop _ -> + Dynamic + + | Texp_hole -> Static + and classify_value_bindings rec_flag env bindings = + (* We use a non-recursive classification, classifying each + binding with respect to the old environment + (before all definitions), even if the bindings are recursive. + + Note: computing a fixpoint in some way would be more + precise, as the following could be allowed: + + let rec topdef = + let rec x = y and y = fun () -> topdef () + in x + *) + ignore rec_flag; + let old_env = env in + let add_value_binding env vb = + match vb.vb_pat.pat_desc with + | Tpat_var (id, _loc, _uid) -> + let size = classify_expression old_env vb.vb_expr in + Ident.add id size env + | _ -> + (* Note: we don't try to compute any size for complex patterns *) + env + in + List.fold_left add_value_binding env bindings + and classify_path env : _ -> Value_rec_types.recursive_binding_kind = function + | Path.Pident x -> + begin + try Ident.find_same x env + with Not_found -> + (* an identifier will be missing from the map if either: + - it is a non-local identifier + (bound outside the letrec-binding we are analyzing) + - or it is bound by a complex (let p = e in ...) local binding + - or it is bound within a module (let module M = ... in ...) + that we are not traversing for size computation + + For non-local identifiers it might be reasonable (although + not completely clear) to consider them Static (they have + already been evaluated), but for the others we must + under-approximate with Not_recursive. + + This could be fixed by a more complete implementation. + *) + Dynamic + end + | Path.Pdot _ | Path.Papply _ | Path.Pextra_ty _ -> + (* local modules could have such paths to local definitions; + classify_expression could be extend to compute module + shapes more precisely *) + Dynamic + and classify_module_expression env mexp : sd = + match mexp.mod_desc with + | Tmod_hole -> + Dynamic + | Tmod_ident (path, _) -> + classify_path env path + | Tmod_structure _ -> + Static + | Tmod_functor _ -> + Static + | Tmod_apply _ -> + Dynamic + | Tmod_apply_unit _ -> + Dynamic + | Tmod_constraint (mexp, _, _, coe) -> + begin match coe with + | Tcoerce_none -> + classify_module_expression env mexp + | Tcoerce_structure _ -> + Static + | Tcoerce_functor _ -> + Static + | Tcoerce_primitive _ -> + Misc.fatal_error "letrec: primitive coercion on a module" + | Tcoerce_alias _ -> + Misc.fatal_error "letrec: alias coercion on a module" + end + | Tmod_unpack (e, _) -> + classify_expression env e + in classify_expression Ident.empty + + +(** {1 Usage of recursive variables} *) + +module Mode = struct + (** For an expression in a program, its "usage mode" represents + static information about how the value produced by the expression + will be used by the context around it. *) + type t = + | Ignore + (** [Ignore] is for subexpressions that are not used at all during + the evaluation of the whole program. This is the mode of + a variable in an expression in which it does not occur. *) + + | Delay + (** A [Delay] context can be fully evaluated without evaluating its argument + , which will only be needed at a later point of program execution. For + example, [fun x -> ?] or [lazy ?] are [Delay] contexts. *) + + | Guard + (** A [Guard] context returns the value as a member of a data structure, + for example a variant constructor or record. The value can safely be + defined mutually-recursively with their context, for example in + [let rec li = 1 :: li]. + When these subexpressions participate in a cyclic definition, + this definition is productive/guarded. + + The [Guard] mode is also used when a value is not dereferenced, + it is returned by a sub-expression, but the result of this + sub-expression is discarded instead of being returned. + For example, the subterm [?] is in a [Guard] context + in [let _ = ? in e] and in [?; e]. + When these subexpressions participate in a cyclic definition, + they cannot create a self-loop. + *) + + | Return + (** A [Return] context returns its value without further inspection. + This value cannot be defined mutually-recursively with its context, + as there is a risk of self-loop: in [let rec x = y and y = x], the + two definitions use a single variable in [Return] context. *) + + | Dereference + (** A [Dereference] context consumes, inspects and uses the value + in arbitrary ways. Such a value must be fully defined at the point + of usage, it cannot be defined mutually-recursively with its context. *) + + let equal = ((=) : t -> t -> bool) + + (* Lower-ranked modes demand/use less of the variable/expression they qualify + -- so they allow more recursive definitions. + + Ignore < Delay < Guard < Return < Dereference + *) + let rank = function + | Ignore -> 0 + | Delay -> 1 + | Guard -> 2 + | Return -> 3 + | Dereference -> 4 + + (* Returns the more conservative (highest-ranking) mode of the two + arguments. + + In judgments we write (m + m') for (join m m'). + *) + let join m m' = + if rank m >= rank m' then m else m' + + (* If x is used with the mode m in e[x], and e[x] is used with mode + m' in e'[e[x]], then x is used with mode m'[m] (our notation for + "compose m' m") in e'[e[x]]. + + Return is neutral for composition: m[Return] = m = Return[m]. + + Composition is associative and [Ignore] is a zero/annihilator for + it: (compose Ignore m) and (compose m Ignore) are both Ignore. *) + let compose m' m = match m', m with + | Ignore, _ | _, Ignore -> Ignore + | Dereference, _ -> Dereference + | Delay, _ -> Delay + | Guard, Return -> Guard + | Guard, ((Dereference | Guard | Delay) as m) -> m + | Return, Return -> Return + | Return, ((Dereference | Guard | Delay) as m) -> m +end + +type mode = Mode.t = Ignore | Delay | Guard | Return | Dereference + +module Env : +sig + type t + + val single : Ident.t -> Mode.t -> t + (** Create an environment with a single identifier used with a given mode. + *) + + val empty : t + (** An environment with no used identifiers. *) + + val find : Ident.t -> t -> Mode.t + (** Find the mode of an identifier in an environment. The default mode is + Ignore. *) + + val unguarded : t -> Ident.t list -> Ident.t list + (** unguarded e l: the list of all identifiers in l that are dereferenced or + returned in the environment e. *) + + val dependent : t -> Ident.t list -> Ident.t list + (** dependent e l: the list of all identifiers in l that are used in e + (not ignored). *) + + val join : t -> t -> t + val join_list : t list -> t + (** Environments can be joined pointwise (variable per variable) *) + + val compose : Mode.t -> t -> t + (** Environment composition m[G] extends mode composition m1[m2] + by composing each mode in G pointwise *) + + val remove : Ident.t -> t -> t + (** Remove an identifier from an environment. *) + + val take: Ident.t -> t -> Mode.t * t + (** Remove an identifier from an environment, and return its mode *) + + val remove_list : Ident.t list -> t -> t + (** Remove all the identifiers of a list from an environment. *) + + val equal : t -> t -> bool +end = struct + module M = Map.Make(Ident) + + (** A "t" maps each rec-bound variable to an access status *) + type t = Mode.t M.t + + let equal = M.equal Mode.equal + + let find (id: Ident.t) (tbl: t) = + try M.find id tbl with Not_found -> Ignore + + let empty = M.empty + + let join (x: t) (y: t) = + M.fold + (fun (id: Ident.t) (v: Mode.t) (tbl: t) -> + let v' = find id tbl in + M.add id (Mode.join v v') tbl) + x y + + let join_list li = List.fold_left join empty li + + let compose m env = + M.map (Mode.compose m) env + + let single id mode = M.add id mode empty + + let unguarded env li = + List.filter (fun id -> Mode.rank (find id env) > Mode.rank Guard) li + + let dependent env li = + List.filter (fun id -> Mode.rank (find id env) > Mode.rank Ignore) li + + let remove = M.remove + + let take id env = (find id env, remove id env) + + let remove_list l env = + List.fold_left (fun env id -> M.remove id env) env l +end + +let remove_pat pat env = + Env.remove_list (pat_bound_idents pat) env + +let remove_patlist pats env = + List.fold_right remove_pat pats env + +(* Usage mode judgments. + + There are two main groups of judgment functions: + + - Judgments of the form "G |- ... : m" + compute the environment G of a subterm ... from its mode m, so + the corresponding function has type [... -> Mode.t -> Env.t]. + + We write [... -> term_judg] in this case. + + - Judgments of the form "G |- ... : m -| G'" + + correspond to binding constructs (for example "let x = e" in the + term "let x = e in body") that have both an exterior environment + G (the environment of the whole term "let x = e in body") and an + interior environment G' (the environment at the "in", after the + binding construct has introduced new names in scope). + + For example, let-binding could be given the following rule: + + G |- e : m + m' + ----------------------------------- + G+G' |- (let x = e) : m -| x:m', G' + + Checking the whole term composes this judgment + with the "G |- e : m" form for the let body: + + G |- (let x = e) : m -| G' + G' |- body : m + ------------------------------- + G |- let x = e in body : m + + To this judgment "G |- e : m -| G'" our implementation gives the + type [... -> Mode.t -> Env.t -> Env.t]: it takes the mode and + interior environment as inputs, and returns the exterior + environment. + + We write [... -> bind_judg] in this case. +*) +type term_judg = Mode.t -> Env.t +type bind_judg = Mode.t -> Env.t -> Env.t + +let option : 'a. ('a -> term_judg) -> 'a option -> term_judg = + fun f o m -> match o with + | None -> Env.empty + | Some v -> f v m +let list : 'a. ('a -> term_judg) -> 'a list -> term_judg = + fun f li m -> + List.fold_left (fun env item -> Env.join env (f item m)) Env.empty li +let array : 'a. ('a -> term_judg) -> 'a array -> term_judg = + fun f ar m -> + Array.fold_left (fun env item -> Env.join env (f item m)) Env.empty ar + +let single : Ident.t -> term_judg = Env.single +let remove_id : Ident.t -> term_judg -> term_judg = + fun id f m -> Env.remove id (f m) +let remove_ids : Ident.t list -> term_judg -> term_judg = + fun ids f m -> Env.remove_list ids (f m) + +let join : term_judg list -> term_judg = + fun li m -> Env.join_list (List.map (fun f -> f m) li) + +let empty = fun _ -> Env.empty + +(* A judgment [judg] takes a mode from the context as input, and + returns an environment. The judgment [judg << m], given a mode [m'] + from the context, evaluates [judg] in the composed mode [m'[m]]. *) +let (<<) : term_judg -> Mode.t -> term_judg = + fun f inner_mode -> fun outer_mode -> f (Mode.compose outer_mode inner_mode) + +(* A binding judgment [binder] expects a mode and an inner environment, + and returns an outer environment. [binder >> judg] computes + the inner environment as the environment returned by [judg] + in the ambient mode. *) +let (>>) : bind_judg -> term_judg -> term_judg = + fun binder term mode -> binder mode (term mode) + +(* Expression judgment: + G |- e : m + where (m) is an input of the code and (G) is an output; + in the Prolog mode notation, this is (+G |- -e : -m). +*) +let rec expression : Typedtree.expression -> term_judg = + fun exp -> match exp.exp_desc with + | Texp_ident (pth, _, _) -> + path pth + | Texp_let (rec_flag, bindings, body) -> + (* + G |- : m -| G' + G' |- body : m + ------------------------------- + G |- let in body : m + *) + value_bindings rec_flag bindings >> expression body + | Texp_letmodule (x, _, _, mexp, e) -> + module_binding (x, mexp) >> expression e + | Texp_match (e, cases, _) -> + (* + (Gi; mi |- pi -> ei : m)^i + G |- e : sum(mi)^i + ---------------------------------------------- + G + sum(Gi)^i |- match e with (pi -> ei)^i : m + *) + (fun mode -> + let pat_envs, pat_modes = + List.split (List.map (fun c -> case c mode) cases) in + let env_e = expression e (List.fold_left Mode.join Ignore pat_modes) in + Env.join_list (env_e :: pat_envs)) + | Texp_for (_, _, low, high, _, body) -> + (* + G1 |- low: m[Dereference] + G2 |- high: m[Dereference] + G3 |- body: m[Guard] + --- + G1 + G2 + G3 |- for _ = low to high do body done: m + *) + join [ + expression low << Dereference; + expression high << Dereference; + expression body << Guard; + ] + | Texp_constant _ -> + empty + | Texp_new (pth, _, _) -> + (* + G |- c: m[Dereference] + ----------------------- + G |- new c: m + *) + path pth << Dereference + | Texp_instvar (self_path, pth, _inst_var) -> + join [path self_path << Dereference; path pth] + | Texp_apply ({exp_desc = Texp_ident (_, _, vd)}, [_, Some arg]) + when is_ref vd -> + (* + G |- e: m[Guard] + ------------------ + G |- ref e: m + *) + expression arg << Guard + | Texp_apply (e, args) -> + (* [args] may contain omitted arguments, corresponding to labels in + the function's type that were not passed in the actual application. + The arguments before the first omitted argument are passed to the + function immediately, so they are dereferenced. The arguments after + the first omitted one are stored in a closure, so guarded. + The function itself is called immediately (dereferenced) if there + is at least one argument before the first omitted one. + On the other hand, if the first argument is omitted then the + function is stored in the closure without being called. *) + let rec split_args ~has_omitted_arg = function + | [] -> [], [] + | (_, None) :: rest -> split_args ~has_omitted_arg:true rest + | (_, Some arg) :: rest -> + let applied, delayed = split_args ~has_omitted_arg rest in + if has_omitted_arg + then applied, arg :: delayed + else arg :: applied, delayed + in + let applied, delayed = split_args ~has_omitted_arg:false args in + let function_mode = + match applied with + | [] -> Guard + | _ :: _ -> Dereference + in + join [expression e << function_mode; + list expression applied << Dereference; + list expression delayed << Guard] + | Texp_tuple exprs -> + list expression exprs << Guard + | Texp_array exprs -> + let array_mode = match Typeopt.array_kind exp with + | Lambda.Pfloatarray -> + (* (flat) float arrays unbox their elements *) + Dereference + | Lambda.Pgenarray -> + (* This is counted as a use, because constructing a generic array + involves inspecting to decide whether to unbox (PR#6939). *) + Dereference + | Lambda.Paddrarray | Lambda.Pintarray -> + (* non-generic, non-float arrays act as constructors *) + Guard + in + list expression exprs << array_mode + | Texp_construct (_, desc, exprs) -> + let access_constructor = + match desc.cstr_tag with + | Cstr_extension (pth, _) -> + path pth << Dereference + | _ -> empty + in + let m' = match desc.cstr_tag with + | Cstr_unboxed -> + Return + | Cstr_constant _ | Cstr_block _ | Cstr_extension _ -> + Guard + in + join [ + access_constructor; + list expression exprs << m' + ] + | Texp_variant (_, eo) -> + (* + G |- e: m[Guard] + ------------------ ----------- + G |- `A e: m [] |- `A: m + *) + option expression eo << Guard + | Texp_record { fields = es; extended_expression = eo; + representation = rep } -> + let field_mode = match rep with + | Record_float -> Dereference + | Record_unboxed _ -> Return + | Record_regular | Record_inlined _ + | Record_extension _ -> Guard + in + let field (_label, field_def) = match field_def with + Kept _ -> empty + | Overridden (_, e) -> expression e + in + join [ + array field es << field_mode; + option expression eo << Dereference + ] + | Texp_ifthenelse (cond, ifso, ifnot) -> + (* + Gc |- c: m[Dereference] + G1 |- e1: m + G2 |- e2: m + --- + Gc + G1 + G2 |- if c then e1 else e2: m + + Note: `if c then e1 else e2` is treated in the same way as + `match c with true -> e1 | false -> e2` + *) + join [ + expression cond << Dereference; + expression ifso; + option expression ifnot; + ] + | Texp_setfield (e1, _, _, e2) -> + (* + G1 |- e1: m[Dereference] + G2 |- e2: m[Dereference] + --- + G1 + G2 |- e1.x <- e2: m + + Note: e2 is dereferenced in the case of a field assignment to + a record of unboxed floats in that case, e2 evaluates to + a boxed float and it is unboxed on assignment. + *) + join [ + expression e1 << Dereference; + expression e2 << Dereference; + ] + | Texp_sequence (e1, e2) -> + (* + G1 |- e1: m[Guard] + G2 |- e2: m + -------------------- + G1 + G2 |- e1; e2: m + + Note: `e1; e2` is treated in the same way as `let _ = e1 in e2` + *) + join [ + expression e1 << Guard; + expression e2; + ] + | Texp_while (cond, body) -> + (* + G1 |- cond: m[Dereference] + G2 |- body: m[Guard] + --------------------------------- + G1 + G2 |- while cond do body done: m + *) + join [ + expression cond << Dereference; + expression body << Guard; + ] + | Texp_send (e1, _) -> + (* + G |- e: m[Dereference] + ---------------------- (plus weird 'eo' option) + G |- e#x: m + *) + join [ + expression e1 << Dereference + ] + | Texp_field (e, _, _) -> + (* + G |- e: m[Dereference] + ----------------------- + G |- e.x: m + *) + expression e << Dereference + | Texp_setinstvar (pth,_,_,e) -> + (* + G |- e: m[Dereference] + ---------------------- + G |- x <- e: m + *) + join [ + path pth << Dereference; + expression e << Dereference; + ] + | Texp_letexception ({ext_id}, e) -> + (* G |- e: m + ---------------------------- + G |- let exception A in e: m + *) + remove_id ext_id (expression e) + | Texp_assert (e, _) -> + (* + G |- e: m[Dereference] + ----------------------- + G |- assert e: m + + Note: `assert e` is treated just as if `assert` was a function. + *) + expression e << Dereference + | Texp_pack mexp -> + (* + G |- M: m + ---------------- + G |- module M: m + *) + modexp mexp + | Texp_object (clsstrct, _) -> + class_structure clsstrct + | Texp_try (e, cases) -> + (* + G |- e: m (Gi; _ |- pi -> ei : m)^i + -------------------------------------------- + G + sum(Gi)^i |- try e with (pi -> ei)^i : m + + Contrarily to match, the patterns p do not inspect + the value of e, so their mode does not influence the + mode of e. + *) + let case_env c m = fst (case c m) in + join [ + expression e; + list case_env cases; + ] + | Texp_override (pth, fields) -> + (* + G |- pth : m (Gi |- ei : m[Dereference])^i + ---------------------------------------------------- + G + sum(Gi)^i |- {< (xi = ei)^i >} (at path pth) : m + + Note: {< .. >} is desugared to a function application, but + the function implementation might still use its arguments in + a guarded way only -- intuitively it should behave as a constructor. + We could possibly refine the arguments' Dereference into Guard here. + *) + let field (_, _, arg) = expression arg in + join [ + path pth << Dereference; + list field fields << Dereference; + ] + | Texp_function (params, body) -> + (* + G |-{body} b : m[Delay] + (Hj |-{def} Pj : m[Delay])^j + H := sum(Hj)^j + ps := sum(pat(Pj))^j + ----------------------------------- + G + H - ps |- fun (Pj)^j -> b : m + *) + let param_pat param = + (* param P ::= + | ?(pat = expr) + | pat + + Define pat(P) as + pat if P = ?(pat = expr) + pat if P = pat + *) + match param.fp_kind with + | Tparam_pat pat -> pat + | Tparam_optional_default (pat, _) -> pat + in + (* Optional argument defaults. + + G |-{def} P : m + *) + let param_default param = + match param.fp_kind with + | Tparam_optional_default (_, default) -> + (* + G |- e : m + ------------------ + G |-{def} ?(p=e) : m + *) + expression default + | Tparam_pat _ -> + (* + ------------------ + . |-{def} p : m + *) + empty + in + let patterns = List.map param_pat params in + let defaults = List.map param_default params in + let body = function_body body in + let f = join (body :: defaults) << Delay in + (fun m -> + let env = f m in + remove_patlist patterns env) + | Texp_lazy e -> + (* + G |- e: m[Delay] + ---------------- (modulo some subtle compiler optimizations) + G |- lazy e: m + *) + let lazy_mode = match Typeopt.classify_lazy_argument e with + | `Constant_or_function + | `Identifier _ + | `Float_that_cannot_be_shortcut -> + Return + | `Other -> + Delay + in + expression e << lazy_mode + | Texp_letop{let_; ands; body; _} -> + let case_env c m = fst (case c m) in + join [ + list binding_op (let_ :: ands) << Dereference; + case_env body << Delay + ] + | Texp_unreachable | Texp_hole -> + (* + ---------- + [] |- .: m + *) + empty + | Texp_extension_constructor (_lid, pth) -> + path pth << Dereference + | Texp_open (od, e) -> + open_declaration od >> expression e + +(* Function bodies. + + G |-{body} b : m +*) +and function_body body = + match body with + | Tfunction_body body -> + (* + G |- e : m + ------------------ + G |-{body} e : m (**) + + (**) The "e" here stands for [Tfunction_body] as opposed to + [Tfunction_cases]. + *) + expression body + | Tfunction_cases { cases; _ } -> + (* + (Gi; _ |- pi -> ei : m)^i (**) + ------------------ + sum(Gi)^i |-{body} function (pi -> ei)^i : m + + (**) Contrarily to match, the values that are pattern-matched + are bound locally, so the pattern modes do not influence + the final environment. + *) + List.map (fun c mode -> fst (case c mode)) cases + |> join + +and binding_op : Typedtree.binding_op -> term_judg = + fun bop -> + join [path bop.bop_op_path; expression bop.bop_exp] + +and class_structure : Typedtree.class_structure -> term_judg = + fun cs -> list class_field cs.cstr_fields + +and class_field : Typedtree.class_field -> term_judg = + fun cf -> match cf.cf_desc with + | Tcf_inherit (_, ce, _super, _inh_vars, _inh_meths) -> + class_expr ce << Dereference + | Tcf_val (_lab, _mut, _, cfk, _) -> + class_field_kind cfk + | Tcf_method (_, _, cfk) -> + class_field_kind cfk + | Tcf_constraint _ -> + empty + | Tcf_initializer e -> + expression e << Dereference + | Tcf_attribute _ -> + empty + +and class_field_kind : Typedtree.class_field_kind -> term_judg = + fun cfk -> match cfk with + | Tcfk_virtual _ -> + empty + | Tcfk_concrete (_, e) -> + expression e << Dereference + +and modexp : Typedtree.module_expr -> term_judg = + fun mexp -> match mexp.mod_desc with + | Tmod_ident (pth, _) -> + path pth + | Tmod_structure s -> + structure s + | Tmod_functor (_, e) -> + modexp e << Delay + | Tmod_apply (f, p, _) -> + join [ + modexp f << Dereference; + modexp p << Dereference; + ] + | Tmod_apply_unit f -> + modexp f << Dereference + | Tmod_constraint (mexp, _, _, coe) -> + let rec coercion coe k = match coe with + | Tcoerce_none -> + k Return + | Tcoerce_structure _ + | Tcoerce_functor _ -> + (* These coercions perform a shallow copy of the input module, + by creating a new module with fields obtained by accessing + the same fields in the input module. *) + k Dereference + | Tcoerce_primitive _ -> + (* This corresponds to 'external' declarations, + and the coercion ignores its argument *) + k Ignore + | Tcoerce_alias (_, pth, coe) -> + (* Alias coercions ignore their arguments, but they evaluate + their alias module 'pth' under another coercion. *) + coercion coe (fun m -> path pth << m) + in + coercion coe (fun m -> modexp mexp << m) + | Tmod_unpack (e, _) -> + expression e + | Tmod_hole -> fun _ -> Env.empty + + +(* G |- pth : m *) +and path : Path.t -> term_judg = + (* + ------------ + x: m |- x: m + + G |- A: m[Dereference] + ----------------------- + G |- A.x: m + + G1 |- A: m[Dereference] + G2 |- B: m[Dereference] + ------------------------ (as for term application) + G1 + G2 |- A(B): m + *) + fun pth -> match pth with + | Path.Pident x -> + single x + | Path.Pdot (t, _) -> + path t << Dereference + | Path.Papply (f, p) -> + join [ + path f << Dereference; + path p << Dereference; + ] + | Path.Pextra_ty (p, _extra) -> + path p + +(* G |- struct ... end : m *) +and structure : Typedtree.structure -> term_judg = + (* + G1, {x: _, x in vars(G1)} |- item1: G2 + ... + Gn in m + G2, {x: _, x in vars(G2)} |- item2: G3 + ... + Gn in m + ... + Gn, {x: _, x in vars(Gn)} |- itemn: [] in m + --- + (G1 + ... + Gn) - V |- struct item1 ... itemn end: m + *) + fun s m -> + List.fold_right (fun it env -> structure_item it m env) + s.str_items Env.empty + +(* G |- : m -| G' + where G is an output and m, G' are inputs *) +and structure_item : Typedtree.structure_item -> bind_judg = + fun s m env -> match s.str_desc with + | Tstr_eval (e, _) -> + (* + Ge |- e: m[Guard] + G |- items: m -| G' + --------------------------------- + Ge + G |- (e;; items): m -| G' + + The expression `e` is treated in the same way as let _ = e + *) + let judg_e = expression e << Guard in + Env.join (judg_e m) env + | Tstr_value (rec_flag, bindings) -> + value_bindings rec_flag bindings m env + | Tstr_module {mb_id; mb_expr} -> + module_binding (mb_id, mb_expr) m env + | Tstr_recmodule mbs -> + let bindings = List.map (fun {mb_id; mb_expr} -> (mb_id, mb_expr)) mbs in + recursive_module_bindings bindings m env + | Tstr_primitive _ -> + env + | Tstr_type _ -> + (* + ------------------- + G |- type t: m -| G + *) + env + | Tstr_typext {tyext_constructors = exts; _} -> + let ext_ids = List.map (fun {ext_id = id; _} -> id) exts in + Env.join + (list extension_constructor exts m) + (Env.remove_list ext_ids env) + | Tstr_exception {tyexn_constructor = ext; _} -> + Env.join + (extension_constructor ext m) + (Env.remove ext.ext_id env) + | Tstr_modtype _ + | Tstr_class_type _ + | Tstr_attribute _ -> + env + | Tstr_open od -> + open_declaration od m env + | Tstr_class classes -> + let class_ids = + let class_id ({ci_id_class = id; _}, _) = id in + List.map class_id classes in + let class_declaration ({ci_expr; _}, _) m = + Env.remove_list class_ids (class_expr ci_expr m) in + Env.join + (list class_declaration classes m) + (Env.remove_list class_ids env) + | Tstr_include { incl_mod = mexp; incl_type = mty; _ } -> + let included_ids = List.map Types.signature_item_id mty in + Env.join (modexp mexp m) (Env.remove_list included_ids env) + +(* G |- module M = E : m -| G *) +and module_binding : (Ident.t option * Typedtree.module_expr) -> bind_judg = + fun (id, mexp) m env -> + (* + GE |- E: m[mM + Guard] + ------------------------------------- + GE + G |- module M = E : m -| M:mM, G + *) + let judg_E, env = + match id with + | None -> modexp mexp << Guard, env + | Some id -> + let mM, env = Env.take id env in + let judg_E = modexp mexp << (Mode.join mM Guard) in + judg_E, env + in + Env.join (judg_E m) env + +and open_declaration : Typedtree.open_declaration -> bind_judg = + fun { open_expr = mexp; open_bound_items = sg; _ } m env -> + let judg_E = modexp mexp in + let bound_ids = List.map Types.signature_item_id sg in + Env.join (judg_E m) (Env.remove_list bound_ids env) + +and recursive_module_bindings + : (Ident.t option * Typedtree.module_expr) list -> bind_judg = + fun m_bindings m env -> + let mids = List.filter_map fst m_bindings in + let binding (mid, mexp) m = + let judg_E = + match mid with + | None -> modexp mexp << Guard + | Some mid -> + let mM = Env.find mid env in + modexp mexp << (Mode.join mM Guard) + in + Env.remove_list mids (judg_E m) + in + Env.join (list binding m_bindings m) (Env.remove_list mids env) + +and class_expr : Typedtree.class_expr -> term_judg = + fun ce -> match ce.cl_desc with + | Tcl_ident (pth, _, _) -> + path pth << Dereference + | Tcl_structure cs -> + class_structure cs + | Tcl_fun (_, _, args, ce, _) -> + let ids = List.map fst args in + remove_ids ids (class_expr ce << Delay) + | Tcl_apply (ce, args) -> + let arg (_label, eo) = option expression eo in + join [ + class_expr ce << Dereference; + list arg args << Dereference; + ] + | Tcl_let (rec_flag, bindings, _, ce) -> + value_bindings rec_flag bindings >> class_expr ce + | Tcl_constraint (ce, _, _, _, _) -> + class_expr ce + | Tcl_open (_, ce) -> + class_expr ce + +and extension_constructor : Typedtree.extension_constructor -> term_judg = + fun ec -> match ec.ext_kind with + | Text_decl _ -> + empty + | Text_rebind (pth, _lid) -> + path pth + +(* G |- let (rec?) (pi = ei)^i : m -| G' *) +and value_bindings : rec_flag -> Typedtree.value_binding list -> bind_judg = + fun rec_flag bindings mode bound_env -> + let all_bound_pats = List.map (fun vb -> vb.vb_pat) bindings in + let outer_env = remove_patlist all_bound_pats bound_env in + let bindings_env = + match rec_flag with + | Nonrecursive -> + (* + (Gi, pi:_ |- ei : m[mbody_i])^i (pi : mbody_i -| D)^i + ------------------------------------------------------------ + Sum(Gi) + (D - (pi)^i) |- let (pi=ei)^i : m -| D + *) + let binding_env {vb_pat; vb_expr; _} m = + let m' = Mode.compose m (pattern vb_pat bound_env) in + remove_pat vb_pat (expression vb_expr m') in + list binding_env bindings mode + | Recursive -> + (* + (Gi, (xj : mdef_ij)^j |- ei : m[mbody_i])^i (xi : mbody_i -| D)^i + G'i = Gi + mdef_ij[G'j] + ------------------------------------------------------------------- + Sum(G'i) + (D - (pi)^i) |- let rec (xi=ei)^i : m -| D + + The (mdef_ij)^i,j are a family of modes over two indices: + mdef_ij represents the mode of use, within e_i the definition of x_i, + of the mutually-recursive variable x_j. + + The (G'i)^i are defined from the (Gi)^i as a family of equations, + whose smallest solution is computed as a least fixpoint. + + The (Gi)^i are the "immediate" dependencies of each (ei)^i + on the outer context (excluding the mutually-defined + variables). + The (G'i)^i contain the "transitive" dependencies as well: + if ei depends on xj, then the dependencies of G'i of xi + must contain the dependencies of G'j, composed by + the mode mdef_ij of use of xj in ei. + + For example, consider: + + let rec z = + let rec x = ref y + and y = ref z + in f x + + this definition should be rejected as the body [f x] + dereferences [x], which can be used to access the + yet-unitialized value [z]. This requires realizing that [x] + depends on [z] through [y], which requires the transitive + closure computation. + + An earlier version of our check would take only the (Gi)^i + instead of the (G'i)^i, which is incorrect and would accept + the example above. + *) + (* [binding_env] takes a binding (x_i = e_i) + and computes (Gi, (mdef_ij)^j). *) + let binding_env {vb_pat = x_i; vb_expr = e_i; _} = + let mbody_i = pattern x_i bound_env in + (* Gi, (x_j:mdef_ij)^j *) + let rhs_env_i = expression e_i (Mode.compose mode mbody_i) in + (* (mdef_ij)^j (for a fixed i) *) + let mutual_modes = + let mdef_ij {vb_pat = x_j; _} = pattern x_j rhs_env_i in + List.map mdef_ij bindings in + (* Gi *) + let env_i = remove_patlist all_bound_pats rhs_env_i in + (* (Gi, (mdef_ij)^j) *) + (env_i, mutual_modes) in + let env, mdef = + List.split (List.map binding_env bindings) in + let rec transitive_closure env = + let transitive_deps env_i mdef_i = + (* Gi, (mdef_ij)^j => Gi + Sum_j mdef_ij[Gj] *) + Env.join env_i + (Env.join_list (List.map2 Env.compose mdef_i env)) in + let env' = List.map2 transitive_deps env mdef in + if List.for_all2 Env.equal env env' + then env' + else transitive_closure env' + in + let env'_i = transitive_closure env in + Env.join_list env'_i + in Env.join bindings_env outer_env + +(* G; m' |- (p -> e) : m + with outputs G, m' and input m + + m' is the mode under which the scrutinee of p + (the value matched against p) is placed. +*) +and case + : 'k . 'k Typedtree.case -> mode -> Env.t * mode + = fun { Typedtree.c_lhs; c_guard; c_rhs } -> + (* + Ge |- e : m Gg |- g : m[Dereference] + G := Ge+Gg p : mp -| G + ---------------------------------------- + G - p; m[mp] |- (p (when g)? -> e) : m + *) + let judg = join [ + option expression c_guard << Dereference; + expression c_rhs; + ] in + (fun m -> + let env = judg m in + (remove_pat c_lhs env), Mode.compose m (pattern c_lhs env)) + +(* p : m -| G + with output m and input G + + m is the mode under which the scrutinee of p is placed. +*) +and pattern : type k . k general_pattern -> Env.t -> mode = fun pat env -> + (* + mp := | Dereference if p is destructuring + | Guard otherwise + me := sum{G(x), x in vars(p)} + -------------------------------------------- + p : (mp + me) -| G + *) + let m_pat = if is_destructuring_pattern pat + then Dereference + else Guard + in + let m_env = + pat_bound_idents pat + |> List.map (fun id -> Env.find id env) + |> List.fold_left Mode.join Ignore + in + Mode.join m_pat m_env + +and is_destructuring_pattern : type k . k general_pattern -> bool = + fun pat -> match pat.pat_desc with + | Tpat_any -> false + | Tpat_var (_, _, _) -> false + | Tpat_alias (pat, _, _, _) -> is_destructuring_pattern pat + | Tpat_constant _ -> true + | Tpat_tuple _ -> true + | Tpat_construct _ -> true + | Tpat_variant _ -> true + | Tpat_record (_, _) -> true + | Tpat_array _ -> true + | Tpat_lazy _ -> true + | Tpat_value pat -> is_destructuring_pattern (pat :> pattern) + | Tpat_exception _ -> false + | Tpat_or (l,r,_) -> + is_destructuring_pattern l || is_destructuring_pattern r + +let is_valid_recursive_expression idlist expr : sd option = + match expr.exp_desc with + | Texp_function _ -> + (* Fast path: functions can never have invalid recursive references *) + Some Static + | _ -> + let rkind = classify_expression expr in + let is_valid = + match rkind with + | Static -> + (* The expression has known size or is constant *) + let ty = expression expr Return in + Env.unguarded ty idlist = [] + | Dynamic -> + (* The expression has unknown size *) + let ty = expression expr Return in + Env.unguarded ty idlist = [] && Env.dependent ty idlist = [] + in + if is_valid then Some rkind else None + +(* A class declaration may contain let-bindings. If they are recursive, + their validity will already be checked by [is_valid_recursive_expression] + during type-checking. This function here prevents a different kind of + invalid recursion, which is the unsafe creations of objects of this class + in the let-binding. For example, + {|class a = let x = new a in object ... end|} + is forbidden, but + {|class a = let x () = new a in object ... end|} + is allowed. +*) +let is_valid_class_expr idlist ce = + let rec class_expr : mode -> Typedtree.class_expr -> Env.t = + fun mode ce -> match ce.cl_desc with + | Tcl_ident (_, _, _) -> + (* + ---------- + [] |- a: m + *) + Env.empty + | Tcl_structure _ -> + (* + ----------------------- + [] |- struct ... end: m + *) + Env.empty + | Tcl_fun (_, _, _, _, _) -> Env.empty + (* + --------------------------- + [] |- fun x1 ... xn -> C: m + *) + | Tcl_apply (_, _) -> Env.empty + | Tcl_let (rec_flag, bindings, _, ce) -> + value_bindings rec_flag bindings mode (class_expr mode ce) + | Tcl_constraint (ce, _, _, _, _) -> + class_expr mode ce + | Tcl_open (_, ce) -> + class_expr mode ce + in + match Env.unguarded (class_expr Return ce) idlist with + | [] -> true + | _ :: _ -> false diff --git a/src/ocaml/typing/value_rec_check.mli b/src/ocaml/typing/value_rec_check.mli new file mode 100644 index 0000000000..8010e7c92c --- /dev/null +++ b/src/ocaml/typing/value_rec_check.mli @@ -0,0 +1,20 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Jeremy Yallop, University of Cambridge *) +(* *) +(* Copyright 2017 Jeremy Yallop *) +(* *) +(* All rights reserved. This file is distributed under the terms of *) +(* the GNU Lesser General Public License version 2.1, with the *) +(* special exception on linking described in the file LICENSE. *) +(* *) +(**************************************************************************) + +val is_valid_recursive_expression : + Ident.t list -> + Typedtree.expression -> + Value_rec_types.recursive_binding_kind option + +val is_valid_class_expr : Ident.t list -> Typedtree.class_expr -> bool diff --git a/src/ocaml/typing/value_rec_types.mli b/src/ocaml/typing/value_rec_types.mli new file mode 100644 index 0000000000..83b838549c --- /dev/null +++ b/src/ocaml/typing/value_rec_types.mli @@ -0,0 +1,27 @@ +(**************************************************************************) +(* *) +(* OCaml *) +(* *) +(* Vincent Laviron, OCamlPro *) +(* *) +(* Copyright 2023 OCamlPro, SAS *) +(* *) +(* All rights reserved. This file is distributed under the terms of *) +(* the GNU Lesser General Public License version 2.1, with the *) +(* special exception on linking described in the file LICENSE. *) +(* *) +(**************************************************************************) + +(** Types related to the compilation of value let-recs (non-functional + recursive definitions) *) + +(** The kind of recursive bindings, as computed by + [Value_rec_check.classify_expression] *) + type recursive_binding_kind = + | Static + (** Bindings for which some kind of pre-allocation scheme is possible. + The expression is allowed to be recursive, as long as its definition does + not inspect recursively defined values. *) + | Dynamic + (** Bindings for which pre-allocation is not possible. + The expression is not allowed to refer to any recursive variable. *) diff --git a/src/ocaml/utils/build_path_prefix_map.ml b/src/ocaml/utils/build_path_prefix_map.ml index c204d3a6b3..17cfac82e2 100644 --- a/src/ocaml/utils/build_path_prefix_map.ml +++ b/src/ocaml/utils/build_path_prefix_map.ml @@ -17,7 +17,7 @@ type path = string type path_prefix = string type error_message = string -let errorf fmt = Printf.kprintf (fun err -> Error err) fmt +let errorf fmt = Printf.ksprintf (fun err -> Error err) fmt let encode_prefix str = let buf = Buffer.create (String.length str) in @@ -95,25 +95,24 @@ let decode_map str = | exception (Shortcut err) -> Error err | map -> Ok map -let rewrite_opt prefix_map path = - let is_prefix = function - | None -> false - | Some { target = _; source } -> - String.length source <= String.length path - && String.equal source (String.sub path 0 (String.length source)) - in - match - List.find is_prefix - (* read key/value pairs from right to left, as the spec demands *) - (List.rev prefix_map) - with - | exception Not_found -> None +let make_target path : pair option -> path option = function | None -> None - | Some { source; target } -> + | Some { target; source } -> + let is_prefix = + String.length source <= String.length path + && String.equal source (String.sub path 0 (String.length source)) in + if is_prefix then Some (target ^ (String.sub path (String.length source) (String.length path - String.length source))) + else None + +let rewrite_first prefix_map path = + List.find_map (make_target path) (List.rev prefix_map) + +let rewrite_all prefix_map path = + List.filter_map (make_target path) (List.rev prefix_map) let rewrite prefix_map path = - match rewrite_opt prefix_map path with + match rewrite_first prefix_map path with | None -> path | Some path -> path diff --git a/src/ocaml/utils/build_path_prefix_map.mli b/src/ocaml/utils/build_path_prefix_map.mli index dbcc8dc16f..d8ec9caf4d 100644 --- a/src/ocaml/utils/build_path_prefix_map.mli +++ b/src/ocaml/utils/build_path_prefix_map.mli @@ -18,6 +18,9 @@ {b Warning:} this module is unstable and part of {{!Compiler_libs}compiler-libs}. + See + {{: https://reproducible-builds.org/specs/build-path-prefix-map/ } + the BUILD_PATH_PREFIX_MAP spec} *) @@ -38,10 +41,21 @@ type map = pair option list val encode_map : map -> string val decode_map : string -> (map, error_message) result -val rewrite_opt : map -> path -> path option -(** [rewrite_opt map path] tries to find a source in [map] +val rewrite_first : map -> path -> path option +(** [rewrite_first map path] tries to find a source in [map] that is a prefix of the input [path]. If it succeeds, it replaces this prefix with the corresponding target. If it fails, it just returns [None]. *) +val rewrite_all : map -> path -> path list +(** [rewrite_all map path] finds all sources in [map] + that are a prefix of the input [path]. For each matching + source, in priority order, it replaces this prefix with + the corresponding target and adds the result to + the returned list. + If there are no matches, it just returns [[]]. *) + val rewrite : map -> path -> path +(** [rewrite path] uses [rewrite_first] to try to find a + mapping for path. If found, it returns that, otherwise + it just returns [path]. *) diff --git a/src/ocaml/utils/clflags.ml b/src/ocaml/utils/clflags.ml index 2c4bd6631e..f507f58362 100644 --- a/src/ocaml/utils/clflags.ml +++ b/src/ocaml/utils/clflags.ml @@ -1,30 +1,23 @@ (** {0 OCaml compiler compatible command-line parameters} *) - +let cmi_file = ref None let include_dirs = ref [] +let hidden_include_dirs = ref [] let fast = ref false let classic = ref false +let all_ppx = ref [] let principal = ref false let real_paths = ref true let recursive_types = ref false let strict_sequence = ref false let applicative_functors = ref true -let unsafe_string = - ref ( - match Merlin_config.ocamlversion with - | `OCaml_4_02_0 | `OCaml_4_02_1 | `OCaml_4_02_2 | `OCaml_4_02_3 - | `OCaml_4_03_0 - | `OCaml_4_04_0 - | `OCaml_4_05_0 -> true - | _ -> false (* -safe-string became the new default in 4.06 *) - ) - let nopervasives = ref false -let strict_formats = ref false +let strict_formats = ref true let open_modules = ref [] let annotations = ref false let binary_annotations = ref true +let store_occurrences = ref true let print_types = ref false let native_code = ref false let error_size = ref 500 diff --git a/src/ocaml/utils/clflags.mli b/src/ocaml/utils/clflags.mli index e06b7a4c6b..4948f58901 100644 --- a/src/ocaml/utils/clflags.mli +++ b/src/ocaml/utils/clflags.mli @@ -6,15 +6,17 @@ (** {1 Relevant settings} Parameters from OCaml compiler which affect Merlin behavior. *) +val cmi_file : string option ref val include_dirs : string list ref +val hidden_include_dirs : string list ref val fast : bool ref val classic : bool ref +val all_ppx : string list ref val principal : bool ref val real_paths : bool ref val recursive_types : bool ref val strict_sequence : bool ref val applicative_functors : bool ref -val unsafe_string : bool ref val nopervasives : bool ref val strict_formats : bool ref val open_modules : string list ref @@ -23,6 +25,7 @@ val open_modules : string list ref Ignored by merlin but kept for compatibility with upstream code. *) val annotations : bool ref val binary_annotations : bool ref +val store_occurrences : bool ref val print_types : bool ref val native_code : bool ref val dont_write_files : bool ref diff --git a/src/ocaml/utils/config.ml b/src/ocaml/utils/config.ml index 77ed946042..4c2a9566f6 100644 --- a/src/ocaml/utils/config.ml +++ b/src/ocaml/utils/config.ml @@ -28,31 +28,31 @@ let version = Sys.ocaml_version let flambda = false -let exec_magic_number = "Caml1999X031" +let ext_obj = ".o_The boot compiler cannot process C objects" + +let exec_magic_number = "Caml1999X034" (* exec_magic_number is duplicated in runtime/caml/exec.h *) -and cmi_magic_number = "Caml1999I031" -and cmo_magic_number = "Caml1999O031" -and cma_magic_number = "Caml1999A031" +and cmi_magic_number = "Caml1999I034" +and cmo_magic_number = "Caml1999O034" +and cma_magic_number = "Caml1999A034" and cmx_magic_number = if flambda then - "Caml1999y031" + "Caml1999y034" else - "Caml1999Y031" + "Caml1999Y034" and cmxa_magic_number = if flambda then - "Caml1999z031" + "Caml1999z034" else - "Caml1999Z031" -and ast_impl_magic_number = "Caml1999M031" -and ast_intf_magic_number = "Caml1999N031" -and cmxs_magic_number = "Caml1999D031" -and cmt_magic_number = "Caml1999T031" + "Caml1999Z034" +and ast_impl_magic_number = "Caml1999M034" +and ast_intf_magic_number = "Caml1999N034" +and cmxs_magic_number = "Caml1999D034" +and cmt_magic_number = "Caml1999T034" let interface_suffix = ref ".mli" let max_tag = 245 - -let safe_string = true let flat_float_array = false let merlin = true diff --git a/src/ocaml/utils/config.mli b/src/ocaml/utils/config.mli index 3cea743f6c..26323f87fa 100644 --- a/src/ocaml/utils/config.mli +++ b/src/ocaml/utils/config.mli @@ -18,6 +18,8 @@ val version: string (* The current version number of the system *) +val ext_obj : string + val interface_suffix: string ref (* Suffix for interface file names *) @@ -45,7 +47,6 @@ val cmt_magic_number: string val max_tag: int (* Biggest tag that can be stored in the header of a regular block. *) -val safe_string: bool val flat_float_array: bool (**/**) diff --git a/src/ocaml/utils/consistbl.ml b/src/ocaml/utils/consistbl.ml index b3299114a4..29289201f6 100644 --- a/src/ocaml/utils/consistbl.ml +++ b/src/ocaml/utils/consistbl.ml @@ -56,8 +56,6 @@ end) = struct with Not_found -> raise (Not_available name) - let set tbl name crc source = Module_name.Tbl.add tbl name (crc, source) - let source tbl name = snd (Module_name.Tbl.find tbl name) let extract l tbl = diff --git a/src/ocaml/utils/consistbl.mli b/src/ocaml/utils/consistbl.mli index 5067addfa7..acc89eb31d 100644 --- a/src/ocaml/utils/consistbl.mli +++ b/src/ocaml/utils/consistbl.mli @@ -47,11 +47,6 @@ end) : sig (* Same as [check], but raise [Not_available] if no CRC was previously associated with [name]. *) - val set: t -> Module_name.t -> Digest.t -> filepath -> unit - (* [set tbl name crc source] forcefully associates [name] with - [crc] in [tbl], even if [name] already had a different CRC - associated with [name] in [tbl]. *) - val source: t -> Module_name.t -> filepath (* [source tbl name] returns the file name associated with [name] if the latter has an associated CRC in [tbl]. diff --git a/src/ocaml/utils/diffing.ml b/src/ocaml/utils/diffing.ml index e5b230e233..94391803ae 100644 --- a/src/ocaml/utils/diffing.ml +++ b/src/ocaml/utils/diffing.ml @@ -36,14 +36,14 @@ type change_kind = | Preservation let style = function - | Preservation -> Misc.Color.[ FG Green ] - | Deletion -> Misc.Color.[ FG Red; Bold] - | Insertion -> Misc.Color.[ FG Red; Bold] - | Modification -> Misc.Color.[ FG Magenta; Bold] + | Preservation -> Misc.Style.[ FG Green ] + | Deletion -> Misc.Style.[ FG Red; Bold] + | Insertion -> Misc.Style.[ FG Red; Bold] + | Modification -> Misc.Style.[ FG Magenta; Bold] let prefix ppf (pos, p) = let sty = style p in - Format.pp_open_stag ppf (Misc.Color.Style sty); + Format.pp_open_stag ppf (Misc.Style.Style sty); Format.fprintf ppf "%i. " pos; Format.pp_close_stag ppf () diff --git a/src/ocaml/utils/diffing.mli b/src/ocaml/utils/diffing.mli index 8fb115feec..7f4d7ced1b 100644 --- a/src/ocaml/utils/diffing.mli +++ b/src/ocaml/utils/diffing.mli @@ -1,4 +1,3 @@ - (**************************************************************************) (* *) (* OCaml *) @@ -81,7 +80,7 @@ type change_kind = | Modification | Preservation val prefix: Format.formatter -> (int * change_kind) -> unit -val style: change_kind -> Misc.Color.style list +val style: change_kind -> Misc.Style.style list type ('left,'right,'eq,'diff) change = diff --git a/src/ocaml/utils/diffing_with_keys.ml b/src/ocaml/utils/diffing_with_keys.ml index 8a313143bd..33a03b4da5 100644 --- a/src/ocaml/utils/diffing_with_keys.ml +++ b/src/ocaml/utils/diffing_with_keys.ml @@ -37,7 +37,7 @@ let prefix ppf x = in let style k ppf inner = let sty = Diffing.style k in - Format.pp_open_stag ppf (Misc.Color.Style sty); + Format.pp_open_stag ppf (Misc.Style.Style sty); Format.kfprintf (fun ppf -> Format.pp_close_stag ppf () ) ppf inner in match x with diff --git a/src/ocaml/utils/load_path.ml b/src/ocaml/utils/load_path.ml index 045af69a47..2707339bac 100644 --- a/src/ocaml/utils/load_path.ml +++ b/src/ocaml/utils/load_path.ml @@ -19,35 +19,86 @@ module STbl = Misc.String.Tbl (* Mapping from basenames to full filenames *) type registry = string STbl.t -let files : registry ref = s_table STbl.create 42 -let files_uncap : registry ref = s_table STbl.create 42 +let visible_files : registry ref = s_table STbl.create 42 +let visible_files_uncap : registry ref = s_table STbl.create 42 + +let hidden_files : registry ref = s_table STbl.create 42 +let hidden_files_uncap : registry ref = s_table STbl.create 42 module Dir = struct type t = { path : string; files : string list; + hidden : bool; } let path t = t.path let files t = t.files + let hidden t = t.hidden + + let find t fn = + if List.mem fn t.files then + Some (Filename.concat t.path fn) + else + None - let create path = - { path; files = Array.to_list (Directory_content_cache.read path) } + let find_normalized t fn = + let fn = Misc.normalized_unit_filename fn in + let search base = + if Misc.normalized_unit_filename base = fn then + Some (Filename.concat t.path base) + else + None + in + List.find_map search t.files + + let create ~hidden path = + { path; files = Array.to_list (Directory_content_cache.read path); hidden } let check t = Directory_content_cache.check t.path end -let dirs = s_ref [] +type auto_include_callback = + (Dir.t -> string -> string option) -> string -> string + +let visible_dirs = s_ref [] +let hidden_dirs = s_ref [] +let no_auto_include _ _ = raise Not_found +let auto_include_callback = ref no_auto_include -let reset () = +let reset_visible () = assert (not Config.merlin || Local_store.is_bound ()); - STbl.clear !files; - STbl.clear !files_uncap; - dirs := [] + STbl.clear !visible_files; + STbl.clear !visible_files_uncap; + visible_dirs := [] + +let reset_hidden () = + assert (not Config.merlin || Local_store.is_bound ()); + STbl.clear !hidden_files; + STbl.clear !hidden_files_uncap; + hidden_dirs := [] + +let reset ?(only_hidden = false) ?(only_visible = false) () = + if not only_visible then reset_hidden (); + if not only_hidden then reset_visible (); + auto_include_callback := no_auto_include + +let get_visible () = List.rev !visible_dirs -let get () = List.rev !dirs -let get_paths () = List.rev_map Dir.path !dirs +let get_path_list () = + Misc.rev_map_end Dir.path !visible_dirs (List.rev_map Dir.path !hidden_dirs) + +type paths = + { visible : string list; + hidden : string list } + +let get_paths () = + { visible = List.rev_map Dir.path !visible_dirs; + hidden = List.rev_map Dir.path !hidden_dirs } + +let get_visible_path_list () = List.rev_map Dir.path !visible_dirs +let get_hidden_path_list () = List.rev_map Dir.path !hidden_dirs (* Optimized version of [add] below, for use in [init] and [remove_dir]: since we are starting from an empty cache, we can avoid checking whether a unit @@ -56,89 +107,164 @@ let get_paths () = List.rev_map Dir.path !dirs let prepend_add dir = List.iter (fun base -> let fn = Filename.concat dir.Dir.path base in - STbl.replace !files base fn; - STbl.replace !files_uncap (String.uncapitalize_ascii base) fn + let filename = Misc.normalized_unit_filename base in + if dir.Dir.hidden then begin + STbl.replace !hidden_files base fn; + STbl.replace !hidden_files_uncap filename fn + end else begin + STbl.replace !visible_files base fn; + STbl.replace !visible_files_uncap filename fn + end ) dir.Dir.files -let init l = +let init ~auto_include ~visible ~hidden = assert (not Config.merlin || Local_store.is_bound ()); - let rec loop_changed acc = function + let rec loop_changed ~hidden acc = function | [] -> Some acc | new_path :: new_rest -> - loop_changed (Dir.create new_path :: acc) new_rest + loop_changed ~hidden (Dir.create ~hidden new_path :: acc) new_rest in - let rec loop_unchanged acc new_paths old_dirs = + let rec loop_unchanged ~hidden acc new_paths old_dirs = match new_paths, old_dirs with | [], [] -> None | new_path :: new_rest, [] -> - loop_changed (Dir.create new_path :: acc) new_rest + loop_changed ~hidden (Dir.create ~hidden new_path :: acc) new_rest | [], _ :: _ -> Some acc | new_path :: new_rest, old_dir :: old_rest -> if String.equal new_path (Dir.path old_dir) then begin if Dir.check old_dir then begin - loop_unchanged (old_dir :: acc) new_rest old_rest + loop_unchanged ~hidden (old_dir :: acc) new_rest old_rest end else begin - loop_changed (Dir.create new_path :: acc) new_rest + loop_changed ~hidden (Dir.create ~hidden new_path :: acc) new_rest end end else begin - loop_changed (Dir.create new_path :: acc) new_rest + loop_changed ~hidden (Dir.create ~hidden new_path :: acc) new_rest end in - match loop_unchanged [] l (List.rev !dirs) with + let () = + match loop_unchanged ~hidden:false [] visible (List.rev !visible_dirs) with + | None -> () + | Some new_dirs -> + reset ~only_visible:true (); + visible_dirs := new_dirs; + List.iter prepend_add new_dirs; + auto_include_callback := auto_include + in + match loop_unchanged ~hidden:true [] hidden (List.rev !hidden_dirs) with | None -> () | Some new_dirs -> - reset (); - dirs := new_dirs; - List.iter prepend_add new_dirs + reset ~only_hidden:true (); + hidden_dirs := new_dirs; + List.iter prepend_add new_dirs; + auto_include_callback := auto_include let remove_dir dir = assert (not Config.merlin || Local_store.is_bound ()); - let new_dirs = List.filter (fun d -> Dir.path d <> dir) !dirs in - if List.compare_lengths new_dirs !dirs <> 0 then begin + let visible = List.filter (fun d -> Dir.path d <> dir) !visible_dirs in + let hidden = List.filter (fun d -> Dir.path d <> dir) !hidden_dirs in + if List.compare_lengths visible !visible_dirs <> 0 + || List.compare_lengths hidden !hidden_dirs <> 0 then begin reset (); - List.iter prepend_add new_dirs; - dirs := new_dirs + visible_dirs := visible; + hidden_dirs := hidden; + List.iter prepend_add hidden; + List.iter prepend_add visible end (* General purpose version of function to add a new entry to load path: We only - add a basename to the cache if it is not already present in the cache, in - order to enforce left-to-right precedence. *) -let add dir = + add a basename to the cache if it is not already present, in order to enforce + left-to-right precedence. *) +let add (dir : Dir.t) = assert (not Config.merlin || Local_store.is_bound ()); + let update base fn visible_files hidden_files = + if dir.hidden && not (STbl.mem !hidden_files base) then + STbl.replace !hidden_files base fn + else if not (STbl.mem !visible_files base) then + STbl.replace !visible_files base fn + in List.iter (fun base -> let fn = Filename.concat dir.Dir.path base in - if not (STbl.mem !files base) then - STbl.replace !files base fn; - let ubase = String.uncapitalize_ascii base in - if not (STbl.mem !files_uncap ubase) then - STbl.replace !files_uncap ubase fn) - dir.Dir.files; - dirs := dir :: !dirs + update base fn visible_files hidden_files; + let ubase = Misc.normalized_unit_filename base in + update ubase fn visible_files_uncap hidden_files_uncap) + dir.files; + if dir.hidden then + hidden_dirs := dir :: !hidden_dirs + else + visible_dirs := dir :: !visible_dirs let append_dir = add -let add_dir dir = add (Dir.create dir) +let add_dir ~hidden dir = add (Dir.create ~hidden dir) (* Add the directory at the start of load path - so basenames are unconditionally added. *) -let prepend_dir dir = +let prepend_dir (dir : Dir.t) = assert (not Config.merlin || Local_store.is_bound ()); prepend_add dir; - dirs := !dirs @ [dir] + if dir.hidden then + hidden_dirs := !hidden_dirs @ [dir] + else + visible_dirs := !visible_dirs @ [dir] let is_basename fn = Filename.basename fn = fn +(* let auto_include_libs libs alert find_in_dir fn = + let scan (lib, lazy dir) = + let file = find_in_dir dir fn in + let alert_and_add_dir _ = + alert lib; + append_dir dir + in + Option.iter alert_and_add_dir file; + file + in + match List.find_map scan libs with + | Some base -> base + | None -> raise Not_found *) + +(* let auto_include_otherlibs = + (* Ensure directories are only ever scanned once *) + let expand = Misc.expand_directory Config.standard_library in + let otherlibs = + let read_lib lib = lazy (Dir.create ~hidden:false (expand ("+" ^ lib))) in + List.map (fun lib -> (lib, read_lib lib)) ["dynlink"; "str"; "unix"] in + auto_include_libs otherlibs *) + +type visibility = Visible | Hidden + +let find_file_in_cache fn visible_files hidden_files = + try (STbl.find !visible_files fn, Visible) with + | Not_found -> (STbl.find !hidden_files fn, Hidden) + let find fn = assert (not Config.merlin || Local_store.is_bound ()); - if is_basename fn && not !Sys.interactive then - STbl.find !files fn - else - Misc.find_in_path (get_paths ()) fn + try + if is_basename fn && not !Sys.interactive then + fst (find_file_in_cache fn visible_files hidden_files) + else + Misc.find_in_path (get_path_list ()) fn + with Not_found -> + !auto_include_callback Dir.find fn -let find_uncap fn = +let find_normalized_with_visibility fn = assert (not Config.merlin || Local_store.is_bound ()); - if is_basename fn && not !Sys.interactive then - STbl.find !files_uncap (String.uncapitalize_ascii fn) - else - Misc.find_in_path_uncap (get_paths ()) fn + try + if is_basename fn && not !Sys.interactive then + find_file_in_cache (Misc.normalized_unit_filename fn) + visible_files_uncap hidden_files_uncap + else + try + (Misc.find_in_path_normalized (get_visible_path_list ()) fn, Visible) + with + | Not_found -> + (Misc.find_in_path_normalized (get_hidden_path_list ()) fn, Hidden) + with Not_found -> + let fn_uncap = Misc.normalized_unit_filename fn in + (!auto_include_callback Dir.find_normalized fn_uncap, Visible) + +let find_normalized fn = fst (find_normalized_with_visibility fn) + +(* Merlin: expose standard reset function *) +let reset () = reset () diff --git a/src/ocaml/utils/load_path.mli b/src/ocaml/utils/load_path.mli index 1f9aba28bf..c467f46522 100644 --- a/src/ocaml/utils/load_path.mli +++ b/src/ocaml/utils/load_path.mli @@ -14,15 +14,15 @@ (** Management of include directories. - This module offers a high level interface to locating files in the - load path, which is constructed from [-I] command line flags and a few + This module offers a high level interface to locating files in the load + path, which is constructed from [-I] and [-H] command line flags and a few other parameters. It makes the assumption that the contents of include directories doesn't change during the execution of the compiler. *) -val add_dir : string -> unit +val add_dir : hidden:bool -> string -> unit (** Add a directory to the end of the load path (i.e. at lowest priority.) *) val remove_dir : string -> unit @@ -31,35 +31,79 @@ val remove_dir : string -> unit val reset : unit -> unit (** Remove all directories *) -val init : string list -> unit -(** [init l] is the same as [reset (); List.iter add_dir (List.rev l)] *) - -val get_paths : unit -> string list -(** Return the list of directories passed to [add_dir] so far. *) - -val find : string -> string -(** Locate a file in the load path. Raise [Not_found] if the file - cannot be found. This function is optimized for the case where the - filename is a basename, i.e. doesn't contain a directory - separator. *) - -val find_uncap : string -> string -(** Same as [find], but search also for uncapitalized name, i.e. if - name is Foo.ml, allow /path/Foo.ml and /path/foo.ml to match. *) - module Dir : sig type t (** Represent one directory in the load path. *) - val create : string -> t + val create : hidden:bool -> string -> t val path : t -> string val files : t -> string list (** All the files in that directory. This doesn't include files in sub-directories of this directory. *) + + val hidden : t -> bool + (** If the modules in this directory should not be bound in the initial + scope *) + + val find : t -> string -> string option + (** [find dir fn] returns the full path to [fn] in [dir]. *) + + val find_normalized : t -> string -> string option + (** As {!find}, but search also for uncapitalized name, i.e. if name is + Foo.ml, either /path/Foo.ml or /path/foo.ml may be returned. *) end +type auto_include_callback = + (Dir.t -> string -> string option) -> string -> string +(** The type of callback functions on for [init ~auto_include] *) + +val no_auto_include : auto_include_callback +(** No automatic directory inclusion: misses in the load path raise [Not_found] + as normal. *) + +val init : + auto_include:auto_include_callback -> visible:string list -> + hidden:string list -> unit +(** [init ~visible ~hidden] is the same as + [reset (); + List.iter add_dir (List.rev hidden); + List.iter add_dir (List.rev visible)] *) + +(* val auto_include_otherlibs : + config:Mconfig.t -> (string -> unit) -> auto_include_callback *) +(** [auto_include_otherlibs alert] is a callback function to be passed to + {!Load_path.init} and automatically adds [-I +lib] to the load path after + calling [alert lib]. *) + +val get_path_list : unit -> string list +(** Return the list of directories passed to [add_dir] so far. *) + +type paths = + { visible : string list; + hidden : string list } + +val get_paths : unit -> paths +(** Return the directories passed to [add_dir] so far. *) + +val find : string -> string +(** Locate a file in the load path. Raise [Not_found] if the file + cannot be found. This function is optimized for the case where the + filename is a basename, i.e. doesn't contain a directory + separator. *) + +val find_normalized : string -> string +(** Same as [find], but search also for normalized unit name (see + {!Misc.normalized_unit_filename}), i.e. if name is [Foo.ml], allow + [/path/Foo.ml] and [/path/foo.ml] to match. *) + +type visibility = Visible | Hidden + +val find_normalized_with_visibility : string -> string * visibility +(** Same as [find_normalized], but also reports whether the cmi was found in a + -I directory (Visible) or a -H directory (Hidden) *) + val[@deprecated] add : Dir.t -> unit (** Old name for {!append_dir} *) @@ -71,5 +115,6 @@ val prepend_dir : Dir.t -> unit (** [prepend_dir d] adds [d] to the start of the load path (i.e. at highest priority. *) -val get : unit -> Dir.t list -(** Same as [get_paths ()], except that it returns a [Dir.t list]. *) +val get_visible : unit -> Dir.t list +(** Same as [get_paths ()], except that it returns a [Dir.t list], and doesn't + include the -H paths. *) diff --git a/src/ocaml/utils/local_store.mli b/src/ocaml/utils/local_store.mli index ebd5069393..3ea05d5889 100644 --- a/src/ocaml/utils/local_store.mli +++ b/src/ocaml/utils/local_store.mli @@ -23,8 +23,8 @@ (** {1 Creators} *) val s_ref : 'a -> 'a ref -(** Similar to {!val:ref}, except the allocated reference is registered into - the store. *) +(** Similar to {!val:Stdlib.ref}, except the allocated reference is registered + into the store. *) val s_table : ('a -> 'b) -> 'a -> 'b ref (** Used to register hash tables. Those also need to be placed into refs to be diff --git a/src/ocaml/utils/warnings.ml b/src/ocaml/utils/warnings.ml index bdc931a19c..4eb85d8a9e 100644 --- a/src/ocaml/utils/warnings.ml +++ b/src/ocaml/utils/warnings.ml @@ -65,7 +65,8 @@ type t = | Wildcard_arg_to_constant_constr (* 28 *) | Eol_in_string (* 29 *) | Duplicate_definitions of string * string * string * string (*30 *) - | Module_linked_twice of string * string * string (* 31 *) + (* [Module_linked_twice of string * string * string] (* 31 *) + was turned into a hard error *) | Unused_value_declaration of string (* 32 *) | Unused_open of string (* 33 *) | Unused_type_declaration of string (* 34 *) @@ -107,7 +108,7 @@ type t = | Missing_mli (* 70 *) | Unused_tmc_attribute (* 71 *) | Tmc_breaks_tailcall (* 72 *) -;; + | Generative_application_expects_unit (* 73 *) (* If you remove a warning, leave a hole in the numbering. NEVER change the numbers of existing warnings. @@ -147,7 +148,6 @@ let number = function | Wildcard_arg_to_constant_constr -> 28 | Eol_in_string -> 29 | Duplicate_definitions _ -> 30 - | Module_linked_twice _ -> 31 | Unused_value_declaration _ -> 32 | Unused_open _ -> 33 | Unused_type_declaration _ -> 34 @@ -189,10 +189,13 @@ let number = function | Missing_mli -> 70 | Unused_tmc_attribute -> 71 | Tmc_breaks_tailcall -> 72 + | Generative_application_expects_unit -> 73 ;; +(* DO NOT REMOVE the ;; above: it is used by + the testsuite/ests/warnings/mnemonics.mll test to determine where + the definition of the number function above ends *) -let last_warning_number = 72 -;; +let last_warning_number = 73 type description = { number : int; @@ -200,254 +203,338 @@ type description = (* The first element of the list is the current name, any following ones are deprecated. The current name should always be derived mechanically from the constructor name. *) - description : string; } + description : string; + since : Sys.ocaml_release_info option; + (* The compiler version introducing this warning; only tagged for warnings + created after 3.12, which introduced the numbered syntax. *) + } + + let since major minor = Some { Sys.major; minor; patchlevel=0; extra=None } let descriptions = [ { number = 1; names = ["comment-start"]; - description = "Suspicious-looking start-of-comment mark." }; + description = "Suspicious-looking start-of-comment mark."; + since = None }; { number = 2; names = ["comment-not-end"]; - description = "Suspicious-looking end-of-comment mark." }; + description = "Suspicious-looking end-of-comment mark."; + since = None }; { number = 3; names = []; - description = "Deprecated synonym for the 'deprecated' alert." }; + description = "Deprecated synonym for the 'deprecated' alert."; + since = None }; { number = 4; names = ["fragile-match"]; description = "Fragile pattern matching: matching that will remain complete even\n\ \ if additional constructors are added to one of the variant types\n\ - \ matched." }; + \ matched."; + since = None }; { number = 5; names = ["ignored-partial-application"]; description = "Partially applied function: expression whose result has function\n\ - \ type and is ignored." }; + \ type and is ignored."; + since = None }; { number = 6; names = ["labels-omitted"]; - description = "Label omitted in function application." }; + description = "Label omitted in function application."; + since = None }; { number = 7; names = ["method-override"]; - description = "Method overridden." }; + description = "Method overridden."; + since = None }; { number = 8; names = ["partial-match"]; - description = "Partial match: missing cases in pattern-matching." }; + description = "Partial match: missing cases in pattern-matching."; + since = None }; { number = 9; names = ["missing-record-field-pattern"]; - description = "Missing fields in a record pattern." }; + description = "Missing fields in a record pattern."; + since = None }; { number = 10; names = ["non-unit-statement"]; description = "Expression on the left-hand side of a sequence that doesn't have type\n\ - \ \"unit\" (and that is not a function, see warning number 5)." }; + \ \"unit\" (and that is not a function, see warning number 5)."; + since = None }; { number = 11; names = ["redundant-case"]; description = - "Redundant case in a pattern matching (unused match case)." }; + "Redundant case in a pattern matching (unused match case)."; + since = None }; { number = 12; names = ["redundant-subpat"]; - description = "Redundant sub-pattern in a pattern-matching." }; + description = "Redundant sub-pattern in a pattern-matching." ; + since = None}; { number = 13; names = ["instance-variable-override"]; - description = "Instance variable overridden." }; + description = "Instance variable overridden."; + since = None }; { number = 14; names = ["illegal-backslash"]; - description = "Illegal backslash escape in a string constant." }; + description = "Illegal backslash escape in a string constant."; + since = None }; { number = 15; names = ["implicit-public-methods"]; - description = "Private method made public implicitly." }; + description = "Private method made public implicitly."; + since = None }; { number = 16; names = ["unerasable-optional-argument"]; - description = "Unerasable optional argument." }; + description = "Unerasable optional argument."; + since = None }; { number = 17; names = ["undeclared-virtual-method"]; - description = "Undeclared virtual method." }; + description = "Undeclared virtual method."; + since = None }; { number = 18; names = ["not-principal"]; - description = "Non-principal type." }; + description = "Non-principal type."; + since = None }; { number = 19; names = ["non-principal-labels"]; - description = "Type without principality." }; + description = "Type without principality."; + since = None }; { number = 20; names = ["ignored-extra-argument"]; - description = "Unused function argument." }; + description = "Unused function argument."; + since = None }; { number = 21; names = ["nonreturning-statement"]; - description = "Non-returning statement." }; + description = "Non-returning statement."; + since = None }; { number = 22; names = ["preprocessor"]; - description = "Preprocessor warning." }; + description = "Preprocessor warning."; + since = None }; { number = 23; names = ["useless-record-with"]; - description = "Useless record \"with\" clause." }; + description = "Useless record \"with\" clause."; + since = None }; { number = 24; names = ["bad-module-name"]; description = - "Bad module name: the source file name is not a valid OCaml module name."}; + "Bad module name: the source file name is not a valid OCaml module name."; + since = None }; { number = 25; names = []; - description = "Ignored: now part of warning 8." }; + description = "Ignored: now part of warning 8."; + since = None }; { number = 26; names = ["unused-var"]; description = "Suspicious unused variable: unused variable that is bound\n\ \ with \"let\" or \"as\", and doesn't start with an underscore (\"_\")\n\ - \ character." }; + \ character."; + since = None }; { number = 27; names = ["unused-var-strict"]; description = "Innocuous unused variable: unused variable that is not bound with\n\ \ \"let\" nor \"as\", and doesn't start with an underscore (\"_\")\n\ - \ character." }; + \ character."; + since = None }; { number = 28; names = ["wildcard-arg-to-constant-constr"]; description = - "Wildcard pattern given as argument to a constant constructor." }; + "Wildcard pattern given as argument to a constant constructor."; + since = None }; { number = 29; names = ["eol-in-string"]; description = - "Unescaped end-of-line in a string constant (non-portable code)." }; + "Unescaped end-of-line in a string constant (non-portable code)."; + since = None }; { number = 30; names = ["duplicate-definitions"]; description = "Two labels or constructors of the same name are defined in two\n\ - \ mutually recursive types." }; + \ mutually recursive types."; + since = None }; { number = 31; names = ["module-linked-twice"]; - description = "A module is linked twice in the same executable." }; + description = + "A module is linked twice in the same executable.\n\ + \ Ignored: now a hard error (since 5.1)."; + since = None }; { number = 32; names = ["unused-value-declaration"]; - description = "Unused value declaration." }; + description = "Unused value declaration."; + since = since 4 0 }; { number = 33; names = ["unused-open"]; - description = "Unused open statement." }; + description = "Unused open statement."; + since = since 4 0 }; { number = 34; names = ["unused-type-declaration"]; - description = "Unused type declaration." }; + description = "Unused type declaration."; + since = since 4 0 }; { number = 35; names = ["unused-for-index"]; - description = "Unused for-loop index." }; + description = "Unused for-loop index."; + since = since 4 0 }; { number = 36; names = ["unused-ancestor"]; - description = "Unused ancestor variable." }; + description = "Unused ancestor variable."; + since = since 4 0 }; { number = 37; names = ["unused-constructor"]; - description = "Unused constructor." }; + description = "Unused constructor."; + since = since 4 0 }; { number = 38; names = ["unused-extension"]; - description = "Unused extension constructor." }; + description = "Unused extension constructor."; + since = since 4 0 }; { number = 39; names = ["unused-rec-flag"]; - description = "Unused rec flag." }; + description = "Unused rec flag."; + since = since 4 0 }; { number = 40; names = ["name-out-of-scope"]; - description = "Constructor or label name used out of scope." }; + description = "Constructor or label name used out of scope."; + since = since 4 1 }; { number = 41; names = ["ambiguous-name"]; - description = "Ambiguous constructor or label name." }; + description = "Ambiguous constructor or label name."; + since = since 4 1 }; { number = 42; names = ["disambiguated-name"]; description = - "Disambiguated constructor or label name (compatibility warning)." }; + "Disambiguated constructor or label name (compatibility warning)."; + since = since 4 1 }; { number = 43; names = ["nonoptional-label"]; - description = "Nonoptional label applied as optional." }; + description = "Nonoptional label applied as optional."; + since = since 4 1 }; { number = 44; names = ["open-shadow-identifier"]; - description = "Open statement shadows an already defined identifier." }; + description = "Open statement shadows an already defined identifier."; + since = since 4 1 }; { number = 45; names = ["open-shadow-label-constructor"]; description = - "Open statement shadows an already defined label or constructor." }; + "Open statement shadows an already defined label or constructor."; + since = since 4 1 }; { number = 46; names = ["bad-env-variable"]; - description = "Error in environment variable." }; + description = "Error in environment variable."; + since = since 4 1 }; { number = 47; names = ["attribute-payload"]; - description = "Illegal attribute payload." }; + description = "Illegal attribute payload."; + since = since 4 2 }; { number = 48; names = ["eliminated-optional-arguments"]; - description = "Implicit elimination of optional arguments." }; + description = "Implicit elimination of optional arguments."; + since = since 4 2 }; { number = 49; names = ["no-cmi-file"]; - description = "Absent cmi file when looking up module alias." }; + description = "Absent cmi file when looking up module alias."; + since = since 4 2 }; { number = 50; names = ["unexpected-docstring"]; - description = "Unexpected documentation comment." }; + description = "Unexpected documentation comment."; + since = since 4 3 }; { number = 51; names = ["wrong-tailcall-expectation"]; description = - "Function call annotated with an incorrect @tailcall attribute" }; + "Function call annotated with an incorrect @tailcall attribute."; + since = since 4 3 }; { number = 52; names = ["fragile-literal-pattern"]; - description = "Fragile constant pattern." }; + description = "Fragile constant pattern."; + since = since 4 3 }; { number = 53; names = ["misplaced-attribute"]; - description = "Attribute cannot appear in this context." }; + description = "Attribute cannot appear in this context."; + since = since 4 3 }; { number = 54; names = ["duplicated-attribute"]; - description = "Attribute used more than once on an expression." }; + description = "Attribute used more than once on an expression."; + since = since 4 3 }; { number = 55; names = ["inlining-impossible"]; - description = "Inlining impossible." }; + description = "Inlining impossible."; + since = since 4 3 }; { number = 56; names = ["unreachable-case"]; description = - "Unreachable case in a pattern-matching (based on type information)." }; + "Unreachable case in a pattern-matching (based on type information)."; + since = since 4 3 }; { number = 57; names = ["ambiguous-var-in-pattern-guard"]; - description = "Ambiguous or-pattern variables under guard." }; + description = "Ambiguous or-pattern variables under guard."; + since = since 4 3 }; { number = 58; names = ["no-cmx-file"]; - description = "Missing cmx file." }; + description = "Missing cmx file."; + since = since 4 3 }; { number = 59; names = ["flambda-assignment-to-non-mutable-value"]; - description = "Assignment to non-mutable value." }; + description = "Assignment to non-mutable value."; + since = since 4 3 }; { number = 60; names = ["unused-module"]; - description = "Unused module declaration." }; + description = "Unused module declaration."; + since = since 4 4 }; { number = 61; names = ["unboxable-type-in-prim-decl"]; - description = "Unboxable type in primitive declaration." }; + description = "Unboxable type in primitive declaration."; + since = since 4 4 }; { number = 62; names = ["constraint-on-gadt"]; - description = "Type constraint on GADT type declaration." }; + description = "Type constraint on GADT type declaration."; + since = since 4 6 }; { number = 63; names = ["erroneous-printed-signature"]; - description = "Erroneous printed signature." }; + description = "Erroneous printed signature."; + since = since 4 8 }; { number = 64; names = ["unsafe-array-syntax-without-parsing"]; description = - "-unsafe used with a preprocessor returning a syntax tree." }; + "-unsafe used with a preprocessor returning a syntax tree."; + since = since 4 8 }; { number = 65; names = ["redefining-unit"]; - description = "Type declaration defining a new '()' constructor." }; + description = "Type declaration defining a new '()' constructor."; + since = since 4 8 }; { number = 66; names = ["unused-open-bang"]; - description = "Unused open! statement." }; + description = "Unused open! statement."; + since = since 4 8 }; { number = 67; names = ["unused-functor-parameter"]; - description = "Unused functor parameter." }; + description = "Unused functor parameter."; + since = since 4 10 }; { number = 68; names = ["match-on-mutable-state-prevent-uncurry"]; description = "Pattern-matching depending on mutable state prevents the remaining \n\ - \ arguments from being uncurried." }; + \ arguments from being uncurried."; + since = since 4 12 }; { number = 69; names = ["unused-field"]; - description = "Unused record field." }; + description = "Unused record field."; + since = since 4 13 }; { number = 70; names = ["missing-mli"]; - description = "Missing interface file." }; + description = "Missing interface file."; + since = since 4 13 }; { number = 71; names = ["unused-tmc-attribute"]; - description = "Unused @tail_mod_cons attribute" }; + description = "Unused @tail_mod_cons attribute."; + since = since 4 14 }; { number = 72; names = ["tmc-breaks-tailcall"]; description = "A tail call is turned into a non-tail call \ - by the @tail_mod_cons transformation." }; + by the @tail_mod_cons transformation."; + since = since 4 14 }; + { number = 73; + names = ["generative-application-expects-unit"]; + description = "A generative functor is applied to an empty structure \ + (struct end) rather than to ()."; + since = since 5 1 }; ] -;; let name_to_number = let h = Hashtbl.create last_warning_number in @@ -455,7 +542,6 @@ let name_to_number = List.iter (fun name -> Hashtbl.add h name number) names ) descriptions; fun s -> Hashtbl.find_opt h s -;; (* Must be the max number returned by the [number] function. *) @@ -489,7 +575,6 @@ let letter = function | 'y' -> [26] | 'z' -> [27] | _ -> assert false -;; type state = { @@ -504,7 +589,7 @@ let current = { active = Array.make (last_warning_number + 1) true; error = Array.make (last_warning_number + 1) false; - alerts = (Std.String.Set.empty, false); (* all enabled *) + alerts = (Std.String.Set.empty, false); alert_errors = (Std.String.Set.empty, true); (* all soft *) } @@ -617,6 +702,10 @@ type token = | Letter of char * modifier option | Num of int * int * modifier +let ghost_loc_in_file name = + let pos = { Lexing.dummy_pos with pos_fname = name } in + { loc_start = pos; loc_end = pos; loc_ghost = true } + let letter_alert tokens = let print_warning_char ppf c = let lowercase = Char.lowercase_ascii c = c in @@ -655,8 +744,7 @@ let letter_alert tokens = match consecutive_letters with | [] -> None | example :: _ -> - let pos = { Lexing.dummy_pos with pos_fname = "_none_" } in - let nowhere = { loc_start=pos; loc_end=pos; loc_ghost=true } in + let nowhere = ghost_loc_in_file "_none_" in let spelling_hint ppf = let max_seq_len = List.fold_left (fun l x -> Int.max l (List.length x)) @@ -773,7 +861,6 @@ let parse_opt error active errflag s = | '@', Some n -> action Set_all n; None | _ -> parse_and_eval s end -;; let parse_options errflag s = let error = Array.copy (!current).error in @@ -783,17 +870,15 @@ let parse_options errflag s = alerts (* If you change these, don't forget to change them in man/ocamlc.m *) -let defaults_w = "+a-4-7-9-27-29-30-32..42-44-45-48-50-60-66..70";; -let defaults_warn_error = "-a+31";; +let defaults_w = "+a-4-7-9-27-29-30-32..42-44-45-48-50-60-66..70" +let defaults_warn_error = "-a" +let default_disabled_alerts = [ "unstable"; "unsynchronized_access" ] -let () = ignore @@ parse_options false defaults_w;; -let () = ignore @@ parse_options true defaults_warn_error;; -let ref_manual_explanation () = - (* manual references are checked a posteriori by the manual - cross-reference consistency check in manual/tests*) - let[@manual.ref "s:comp-warnings"] chapter, section = 11, 5 in - Printf.sprintf "(See manual section %d.%d)" chapter section +let () = ignore @@ parse_options false defaults_w +let () = ignore @@ parse_options true defaults_warn_error +let () = + List.iter (set_alert ~error:false ~enable:false) default_disabled_alerts let message = function | Comment_start -> @@ -839,7 +924,11 @@ let message = function ("the following instance variables are overridden by the class" :: cname :: ":\n " :: slist) | Instance_variable_override [] -> assert false - | Illegal_backslash -> "illegal backslash escape in string." + | Illegal_backslash -> + "illegal backslash escape in string.\n\ + Hint: Single backslashes \\ are reserved for escape sequences\n\ + (\\n, \\r, ...). Did you check the list of OCaml escape sequences?\n\ + To get a backslash character, escape it with a second backslash: \\\\." | Implicit_public_methods l -> "the following private methods were made public implicitly:\n " ^ String.concat " " l ^ "." @@ -867,10 +956,6 @@ let message = function | Duplicate_definitions (kind, cname, tc1, tc2) -> Printf.sprintf "the %s %s is defined in both types %s and %s." kind cname tc1 tc2 - | Module_linked_twice(modname, file1, file2) -> - Printf.sprintf - "files %s and %s both define a module named %s" - file1 file2 modname | Unused_value_declaration v -> "unused value " ^ v ^ "." | Unused_open s -> "unused open " ^ s ^ "." | Unused_open_bang s -> "unused open! " ^ s ^ "." @@ -957,10 +1042,12 @@ let message = function Printf.sprintf "expected %s" (if b then "tailcall" else "non-tailcall") | Fragile_literal_pattern -> - Printf.sprintf + let[@manual.ref "ss:warn52"] ref_manual = [ 13; 5; 3 ] in + Format.asprintf "Code should not depend on the actual values of\n\ this constructor's arguments. They are only for information\n\ - and may change in future versions. %t" ref_manual_explanation + and may change in future versions. %a" + Misc.print_see_manual ref_manual | Unreachable_case -> "this match case is unreachable.\n\ Consider replacing it with a refutation case ' -> .'" @@ -973,6 +1060,7 @@ let message = function | Inlining_impossible reason -> Printf.sprintf "Cannot inline: %s" reason | Ambiguous_var_in_pattern_guard vars -> + let[@manual.ref "ss:warn57"] ref_manual = [ 13; 5; 4 ] in let vars = List.sort String.compare vars in let vars_explanation = let in_different_places = @@ -985,12 +1073,12 @@ let message = function let vars = String.concat ", " vars in "variables " ^ vars ^ " appear " ^ in_different_places in - Printf.sprintf + Format.asprintf "Ambiguous or-pattern variables under guard;\n\ %s.\n\ Only the first match will be used to evaluate the guard expression.\n\ - %t" - vars_explanation ref_manual_explanation + %a" + vars_explanation Misc.print_see_manual ref_manual | No_cmx_file name -> Printf.sprintf "no cmx file was found in path for module %s, \ @@ -1046,15 +1134,18 @@ let message = function but is never applied in TMC position." | Tmc_breaks_tailcall -> "This call\n\ - is in tail-modulo-cons positionin a TMC function,\n\ + is in tail-modulo-cons position in a TMC function,\n\ but the function called is not itself specialized for TMC,\n\ so the call will not be transformed into a tail call.\n\ Please either mark the called function with the [@tail_mod_cons]\n\ attribute, or mark this call with the [@tailcall false] attribute\n\ to make its non-tailness explicit." + | Generative_application_expects_unit -> + "A generative functor\n\ + should be applied to '()'; using '(struct end)' is deprecated." ;; -let nerrors = ref 0;; +let nerrors = ref 0 type reporting_information = { id : string @@ -1116,7 +1207,7 @@ let report_alert (alert : alert) = sub_locs; } -exception Errors;; +exception Errors let reset_fatal () = nerrors := 0 @@ -1125,18 +1216,24 @@ let check_fatal () = if !nerrors > 0 then begin nerrors := 0; raise Errors; - end; -;; + end + +let pp_since out release_info = + Printf.fprintf out " (since %d.%0*d)" + release_info.Sys.major + (if release_info.Sys.major >= 5 then 0 else 2) + release_info.Sys.minor let help_warnings () = List.iter - (fun {number; description; names} -> + (fun {number; description; names; since} -> let name = match names with | s :: _ -> " [" ^ s ^ "]" | [] -> "" in - Printf.printf "%3i%s %s\n" number name description) + Printf.printf "%3i%s %s%a\n" + number name description (fun out -> Option.iter (pp_since out)) since) descriptions; print_endline " A all warnings"; for i = Char.code 'b' to Char.code 'z' do @@ -1151,7 +1248,6 @@ let help_warnings () = (String.concat ", " (List.map Int.to_string l)) done; exit 0 -;; (* merlin *) @@ -1188,4 +1284,3 @@ let dump ?(verbose=false) () = "alerts", alerts !current.alerts; "alerts_error", alerts !current.alert_errors; ] -;; diff --git a/src/ocaml/utils/warnings.mli b/src/ocaml/utils/warnings.mli index 4691427df0..bb42eec6ef 100644 --- a/src/ocaml/utils/warnings.mli +++ b/src/ocaml/utils/warnings.mli @@ -26,6 +26,9 @@ type loc = { loc_ghost: bool; } +val ghost_loc_in_file : string -> loc +(** Return an empty ghost range located in a given file *) + type field_usage_warning = | Unused | Not_read @@ -65,9 +68,12 @@ type t = | Unused_var of string (* 26 *) | Unused_var_strict of string (* 27 *) | Wildcard_arg_to_constant_constr (* 28 *) - | Eol_in_string (* 29 *) + | Eol_in_string (* 29 + Note: since OCaml 5.2, the lexer normalizes \r\n sequences in + the source file to a single \n character, so the behavior of + newlines in string literals is portable. This warning is + never emitted anymore. *) | Duplicate_definitions of string * string * string * string (* 30 *) - | Module_linked_twice of string * string * string (* 31 *) | Unused_value_declaration of string (* 32 *) | Unused_open of string (* 33 *) | Unused_type_declaration of string (* 34 *) @@ -109,11 +115,11 @@ type t = | Missing_mli (* 70 *) | Unused_tmc_attribute (* 71 *) | Tmc_breaks_tailcall (* 72 *) -;; + | Generative_application_expects_unit (* 73 *) type alert = {kind:string; message:string; def:loc; use:loc} -val parse_options : bool -> string -> alert option;; +val parse_options : bool -> string -> alert option val parse_alert_option: string -> unit (** Disable/enable alerts based on the parameter to the -alert @@ -124,11 +130,11 @@ val parse_alert_option: string -> unit val without_warnings : (unit -> 'a) -> 'a (** Run the thunk with all warnings and alerts disabled. *) -val is_active : t -> bool;; -val is_error : t -> bool;; +val is_active : t -> bool +val is_error : t -> bool -val defaults_w : string;; -val defaults_warn_error : string;; +val defaults_w : string +val defaults_warn_error : string type reporting_information = { id : string @@ -140,9 +146,9 @@ type reporting_information = val report : t -> [ `Active of reporting_information | `Inactive ] val report_alert : alert -> [ `Active of reporting_information | `Inactive ] -exception Errors;; +exception Errors -val check_fatal : unit -> unit;; +val check_fatal : unit -> unit val reset_fatal: unit -> unit val help_warnings: unit -> unit @@ -158,7 +164,8 @@ val mk_lazy: (unit -> 'a) -> 'a Lazy.t type description = { number : int; names : string list; - description : string; } + description : string; + since : Sys.ocaml_release_info option; } val descriptions : description list diff --git a/src/utils/misc.ml b/src/utils/misc.ml index 1c1c2f4093..063539e2b7 100644 --- a/src/utils/misc.ml +++ b/src/utils/misc.ml @@ -87,6 +87,13 @@ let protect_refs = let map_end f l1 l2 = List.map_end ~f l1 l2 +let rev_map_end f l1 l2 = + let rec rmap_f accu = function + | [] -> accu + | hd::tl -> rmap_f (f hd :: accu) tl + in + rmap_f l2 l1 + let rec map_left_right f = function [] -> [] | hd::tl -> let res = f hd in res :: map_left_right f tl @@ -112,7 +119,9 @@ let may_map f x = Option.map ~f x (* File functions *) let remove_file filename = - try Sys.remove filename + try + if Sys.is_regular_file filename + then Sys.remove filename with Sys_error _msg -> () let rec split_path path acc = @@ -260,20 +269,22 @@ let find_in_path_rel path name = else try_dir rem in try_dir path -let find_in_path_uncap ?(fallback="") path name = +let normalized_unit_filename = String.uncapitalize_ascii + +let find_in_path_normalized ?(fallback="") path name = let has_fallback = fallback <> "" in canonicalize_filename begin - let uname = String.uncapitalize name in - let ufallback = String.uncapitalize fallback in + let uname = normalized_unit_filename name in + let ufallback = normalized_unit_filename fallback in List.find_map path ~f:(fun dirname -> if exact_file_exists ~dirname ~basename:uname then Some (Filename.concat dirname uname) else if exact_file_exists ~dirname ~basename:name then Some (Filename.concat dirname name) - else - let () = Logger.log - ~section:"locate" + else + let () = Logger.log + ~section:"locate" ~title:"find_in_path_uncap" "Failed to load %s/%s" dirname name in @@ -379,6 +390,12 @@ let no_overflow_mul a b = let no_overflow_lsl a k = 0 <= k && k < Sys.word_size - 1 && min_int asr k <= a && a <= max_int asr k +let letter_of_int n = + let letter = String.make 1 (Char.chr (Char.code 'a' + n mod 26)) in + let num = n / 26 in + if num = 0 then letter + else letter ^ Int.to_string num + module Int_literal_converter = struct (* To convert integer literals, allowing max_int + 1 (PR#4210) *) let cvt_int_aux str neg of_string = @@ -391,8 +408,45 @@ module Int_literal_converter = struct let nativeint s = cvt_int_aux s Nativeint.neg Nativeint.of_string end +(* [find_first_mono p] assumes that there exists a natural number + N such that [p] is false on [0; N[ and true on [N; max_int], and + returns this N. (See misc.mli for the detailed specification.) *) +let find_first_mono = + let rec find p ~low ~jump ~high = + (* Invariants: + [low, jump, high] are non-negative with [low < high], + [p low = false], + [p high = true]. *) + if low + 1 = high then high + (* ensure that [low + jump] is in ]low; high[ *) + else if jump < 1 then find p ~low ~jump:1 ~high + else if jump >= high - low then find p ~low ~jump:((high - low) / 2) ~high + else if p (low + jump) then + (* We jumped too high: continue with a smaller jump and lower limit *) + find p ~low:low ~jump:(jump / 2) ~high:(low + jump) + else + (* we jumped too low: + continue from [low + jump] with a larger jump *) + let next_jump = max jump (2 * jump) (* avoid overflows *) in + find p ~low:(low + jump) ~jump:next_jump ~high + in + fun p -> + if p 0 then 0 + else find p ~low:0 ~jump:1 ~high:max_int + (* String operations *) +(* let split_null_terminated s = + let[@tail_mod_cons] rec discard_last_sep = function + | [] | [""] -> [] + | x :: xs -> x :: discard_last_sep xs + in + discard_last_sep (String.split_on_char ~sep:'' s) *) + +(* let concat_null_terminated = function + | [] -> "" + | l -> String.concat ~sep:"" (l @ [""]) *) + let chop_extension_if_any fname = try Filename.chop_extension fname with Invalid_argument _ -> fname @@ -472,149 +526,6 @@ let snd4 (_,x,_, _) = x let thd4 (_,_,x,_) = x let for4 (_,_,_,x) = x - -module LongString = struct - type t = bytes array - - let create str_size = - let tbl_size = str_size / Sys.max_string_length + 1 in - let tbl = Array.make tbl_size Bytes.empty in - for i = 0 to tbl_size - 2 do - tbl.(i) <- Bytes.create Sys.max_string_length; - done; - tbl.(tbl_size - 1) <- Bytes.create (str_size mod Sys.max_string_length); - tbl - - let length tbl = - let tbl_size = Array.length tbl in - Sys.max_string_length * (tbl_size - 1) + Bytes.length tbl.(tbl_size - 1) - - let get tbl ind = - Bytes.get tbl.(ind / Sys.max_string_length) (ind mod Sys.max_string_length) - - let set tbl ind c = - Bytes.set tbl.(ind / Sys.max_string_length) (ind mod Sys.max_string_length) - c - - let blit src srcoff dst dstoff len = - for i = 0 to len - 1 do - set dst (dstoff + i) (get src (srcoff + i)) - done - - let output oc tbl pos len = - for i = pos to pos + len - 1 do - output_char oc (get tbl i) - done - - let unsafe_blit_to_bytes src srcoff dst dstoff len = - for i = 0 to len - 1 do - Bytes.unsafe_set dst (dstoff + i) (get src (srcoff + i)) - done - - let input_bytes ic len = - let tbl = create len in - Array.iter (fun str -> really_input ic str 0 (Bytes.length str)) tbl; - tbl -end - -let file_contents filename = - let ic = open_in filename in - try - let str = Bytes.create 1024 in - let buf = Buffer.create 1024 in - let rec loop () = - match input ic str 0 1024 with - | 0 -> () - | n -> - Buffer.add_subbytes buf str 0 n; - loop () - in - loop (); - close_in_noerr ic; - Buffer.contents buf - with exn -> - close_in_noerr ic; - raise exn - -let edit_distance a b cutoff = - let la, lb = String.length a, String.length b in - let cutoff = - (* using max_int for cutoff would cause overflows in (i + cutoff + 1); - we bring it back to the (max la lb) worstcase *) - min (max la lb) cutoff in - if abs (la - lb) > cutoff then None - else begin - (* initialize with 'cutoff + 1' so that not-yet-written-to cases have - the worst possible cost; this is useful when computing the cost of - a case just at the boundary of the cutoff diagonal. *) - let m = Array.make_matrix (la + 1) (lb + 1) (cutoff + 1) in - m.(0).(0) <- 0; - for i = 1 to la do - m.(i).(0) <- i; - done; - for j = 1 to lb do - m.(0).(j) <- j; - done; - for i = 1 to la do - for j = max 1 (i - cutoff - 1) to min lb (i + cutoff + 1) do - let cost = if a.[i-1] = b.[j-1] then 0 else 1 in - let best = - (* insert, delete or substitute *) - min (1 + min m.(i-1).(j) m.(i).(j-1)) (m.(i-1).(j-1) + cost) - in - let best = - (* swap two adjacent letters; we use "cost" again in case of - a swap between two identical letters; this is slightly - redundant as this is a double-substitution case, but it - was done this way in most online implementations and - imitation has its virtues *) - if not (i > 1 && j > 1 && a.[i-1] = b.[j-2] && a.[i-2] = b.[j-1]) - then best - else min best (m.(i-2).(j-2) + cost) - in - m.(i).(j) <- best - done; - done; - let result = m.(la).(lb) in - if result > cutoff - then None - else Some result - end - -let spellcheck env name = - let cutoff = - match String.length name with - | 1 | 2 -> 0 - | 3 | 4 -> 1 - | 5 | 6 -> 2 - | _ -> 3 - in - let compare target acc head = - match edit_distance target head cutoff with - | None -> acc - | Some dist -> - let (best_choice, best_dist) = acc in - if dist < best_dist then ([head], dist) - else if dist = best_dist then (head :: best_choice, dist) - else acc - in - fst (List.fold_left ~f:(compare name) ~init:([], max_int) env) - -let did_you_mean ppf get_choices = - (* flush now to get the error report early, in the (unheard of) case - where the search in the get_choices function would take a bit of - time; in the worst case, the user has seen the error, she can - interrupt the process before the spell-checking terminates. *) - Format.fprintf ppf "@?"; - match get_choices () with - | [] -> () - | choices -> - let rest, last = split_last choices in - Format.fprintf ppf "@\nHint: Did you mean %s%s%s?@?" - (String.concat ~sep:", " rest) - (if rest = [] then "" else " or ") - last - let cut_at s c = let pos = String.index s c in String.sub s ~pos:0 ~len:pos, @@ -628,8 +539,26 @@ let ordinal_suffix n = | 3 when not teen -> "rd" | _ -> "th" -(* Color handling *) +(* Color support handling *) module Color = struct + external isatty : out_channel -> bool = "caml_sys_isatty" + + (* reasonable heuristic on whether colors should be enabled *) + let should_enable_color () = + let term = try Sys.getenv "TERM" with Not_found -> "" in + term <> "dumb" + && term <> "" + && isatty stderr + + type setting = Auto | Always | Never + + let default_setting = Auto + let enabled = ref true + +end + +(* Terminal styling handling *) +module Style = struct (* use ANSI color codes, see https://en.wikipedia.org/wiki/ANSI_escape_code *) type color = | Black @@ -640,7 +569,6 @@ module Color = struct | Magenta | Cyan | White - ;; type style = | FG of color (* foreground *) @@ -674,17 +602,30 @@ module Color = struct type Format.stag += Style of style list + + type tag_style ={ + ansi: style list; + text_open:string; + text_close:string + } + type styles = { - error: style list; - warning: style list; - loc: style list; + error: tag_style; + warning: tag_style; + loc: tag_style; + hint: tag_style; + inline_code: tag_style; } + let no_markup stl = { ansi = stl; text_close = ""; text_open = "" } + let default_styles = { - warning = [Bold; FG Magenta]; - error = [Bold; FG Red]; - loc = [Bold]; - } + warning = no_markup [Bold; FG Magenta]; + error = no_markup [Bold; FG Red]; + loc = no_markup [Bold]; + hint = no_markup [Bold; FG Blue]; + inline_code= { ansi=[Bold]; text_open = {|"|}; text_close = {|"|} } + } let cur_styles = ref default_styles let get_styles () = !cur_styles @@ -693,29 +634,36 @@ module Color = struct (* map a tag to a style, if the tag is known. @raise Not_found otherwise *) let style_of_tag s = match s with - | Format.String_tag "error" -> (!cur_styles).error - | Format.String_tag "warning" -> (!cur_styles).warning + | Format.String_tag "error" -> (!cur_styles).error + | Format.String_tag "warning" ->(!cur_styles).warning | Format.String_tag "loc" -> (!cur_styles).loc - | Style s -> s + | Format.String_tag "hint" -> (!cur_styles).hint + | Format.String_tag "inline_code" -> (!cur_styles).inline_code + | Style s -> no_markup s | _ -> raise Not_found - let color_enabled = ref true + let as_inline_code printer ppf x = + Format.pp_open_stag ppf (Format.String_tag "inline_code"); + printer ppf x; + Format.pp_close_stag ppf () + + let inline_code ppf s = as_inline_code Format.pp_print_string ppf s (* either prints the tag of [s] or delegates to [or_else] *) let mark_open_tag ~or_else s = try let style = style_of_tag s in - if !color_enabled then ansi_of_style_l style else "" + if !Color.enabled then ansi_of_style_l style.ansi else style.text_open with Not_found -> or_else s let mark_close_tag ~or_else s = try - let _ = style_of_tag s in - if !color_enabled then ansi_of_style_l [Reset] else "" + let style = style_of_tag s in + if !Color.enabled then ansi_of_style_l [Reset] else style.text_close with Not_found -> or_else s - (* add color handling to formatter [ppf] *) - let set_color_tag_handling ppf = + (* add tag handling to formatter [ppf] *) + let set_tag_handling ppf = let open Format in let functions = pp_get_formatter_stag_functions ppf () in let functions' = {functions with @@ -726,41 +674,115 @@ module Color = struct pp_set_formatter_stag_functions ppf functions'; () - external isatty : out_channel -> bool = "caml_sys_isatty" - - (* reasonable heuristic on whether colors should be enabled *) - let should_enable_color () = - let term = try Sys.getenv "TERM" with Not_found -> "" in - term <> "dumb" - && term <> "" - && isatty stderr - - type setting = Auto | Always | Never - - let default_setting = Auto - let setup = let first = ref true in (* initialize only once *) let formatter_l = [Format.std_formatter; Format.err_formatter; Format.str_formatter] in let enable_color = function - | Auto -> should_enable_color () - | Always -> true - | Never -> false + | Color.Auto -> Color.should_enable_color () + | Color.Always -> true + | Color.Never -> false in fun o -> if !first then ( first := false; Format.set_mark_tags true; - List.iter ~f:set_color_tag_handling formatter_l; - color_enabled := (match o with + List.iter ~f:set_tag_handling formatter_l; + Color.enabled := (match o with | Some s -> enable_color s - | None -> enable_color default_setting) + | None -> enable_color Color.default_setting) ); () end +let edit_distance a b cutoff = + let la, lb = String.length a, String.length b in + let cutoff = + (* using max_int for cutoff would cause overflows in (i + cutoff + 1); + we bring it back to the (max la lb) worstcase *) + Int.min (Int.max la lb) cutoff in + if abs (la - lb) > cutoff then None + else begin + (* initialize with 'cutoff + 1' so that not-yet-written-to cases have + the worst possible cost; this is useful when computing the cost of + a case just at the boundary of the cutoff diagonal. *) + let m = Array.make_matrix (la + 1) (lb + 1) (cutoff + 1) in + m.(0).(0) <- 0; + for i = 1 to la do + m.(i).(0) <- i; + done; + for j = 1 to lb do + m.(0).(j) <- j; + done; + for i = 1 to la do + for j = Int.max 1 (i - cutoff - 1) to Int.min lb (i + cutoff + 1) do + let cost = if a.[i-1] = b.[j-1] then 0 else 1 in + let best = + (* insert, delete or substitute *) + Int.min (1 + Int.min m.(i-1).(j) m.(i).(j-1)) (m.(i-1).(j-1) + cost) + in + let best = + (* swap two adjacent letters; we use "cost" again in case of + a swap between two identical letters; this is slightly + redundant as this is a double-substitution case, but it + was done this way in most online implementations and + imitation has its virtues *) + if not (i > 1 && j > 1 && a.[i-1] = b.[j-2] && a.[i-2] = b.[j-1]) + then best + else Int.min best (m.(i-2).(j-2) + cost) + in + m.(i).(j) <- best + done; + done; + let result = m.(la).(lb) in + if result > cutoff + then None + else Some result + end + +let spellcheck env name = + let cutoff = + match String.length name with + | 1 | 2 -> 0 + | 3 | 4 -> 1 + | 5 | 6 -> 2 + | _ -> 3 + in + let compare target acc head = + match edit_distance target head cutoff with + | None -> acc + | Some dist -> + let (best_choice, best_dist) = acc in + if dist < best_dist then ([head], dist) + else if dist = best_dist then (head :: best_choice, dist) + else acc + in + let env = List.sort_uniq ~cmp:(fun s1 s2 -> String.compare s2 s1) env in + fst (List.fold_left ~f:(compare name) ~init:([], max_int) env) + +let did_you_mean ppf get_choices = + (* flush now to get the error report early, in the (unheard of) case + where the search in the get_choices function would take a bit of + time; in the worst case, the user has seen the error, she can + interrupt the process before the spell-checking terminates. *) + Format.fprintf ppf "@?"; + match get_choices () with + | [] -> () + | choices -> + let rest, last = split_last choices in + let comma ppf () = Format.fprintf ppf ", " in + Format.fprintf ppf "@\n@{Hint@}: Did you mean %a%s%a?@?" + (Format.pp_print_list ~pp_sep:comma Style.inline_code) rest + (if rest = [] then "" else " or ") + Style.inline_code last + +let print_see_manual ppf manual_section = + let open Format in + fprintf ppf "(see manual section %a)" + (pp_print_list ~pp_sep:(fun f () -> pp_print_char f '.') pp_print_int) + manual_section + let time_spent () = let open Unix in let t = times () in diff --git a/src/utils/misc.mli b/src/utils/misc.mli index 2d8e0fde11..249f8b668b 100644 --- a/src/utils/misc.mli +++ b/src/utils/misc.mli @@ -15,10 +15,19 @@ (** Miscellaneous useful types and functions *) +(** {1 Reporting fatal errors} *) + val fatal_error: string -> 'a + (** Raise the [Fatal_error] exception with the given string. *) + val fatal_errorf: ('a, Format.formatter, unit, 'b) format4 -> 'a + (** Format the arguments according to the given format string + and raise [Fatal_error] with the resulting string. *) + exception Fatal_error of string * Printexc.raw_backtrace +(** {1 Exceptions and finalization} *) + val try_finally : ?always:(unit -> unit) -> ?exceptionally:(unit -> unit) -> @@ -58,23 +67,33 @@ val reraise_preserving_backtrace : exn -> (unit -> unit) -> 'a (** [reraise_preserving_backtrace e f] is (f (); raise e) except that the current backtrace is preserved, even if [f] uses exceptions internally. *) +(** {1 List operations} *) val map_end: ('a -> 'b) -> 'a list -> 'b list -> 'b list - (* [map_end f l t] is [map f l @ t], just more efficient. *) + (** [map_end f l t] is [map f l @ t], just more efficient. *) + +val rev_map_end: ('a -> 'b) -> 'a list -> 'b list -> 'b list + (** [map_end f l t] is [map f (rev l) @ t], just more efficient. *) + val map_left_right: ('a -> 'b) -> 'a list -> 'b list - (* Like [List.map], with guaranteed left-to-right evaluation order *) + (** Like [List.map], with guaranteed left-to-right evaluation order *) + val for_all2: ('a -> 'b -> bool) -> 'a list -> 'b list -> bool - (* Same as [List.for_all] but for a binary predicate. + (** Same as [List.for_all] but for a binary predicate. In addition, this [for_all2] never fails: given two lists with different lengths, it returns false. *) + val replicate_list: 'a -> int -> 'a list - (* [replicate_list elem n] is the list with [n] elements + (** [replicate_list elem n] is the list with [n] elements all identical to [elem]. *) + val list_remove: 'a -> 'a list -> 'a list - (* [list_remove x l] returns a copy of [l] with the first + (** [list_remove x l] returns a copy of [l] with the first element equal to [x] removed. *) + val split_last: 'a list -> 'a list * 'a - (* Return the last element and the other elements of the given list. *) + (** Return the last element and the other elements of the given list. *) + val may: ('a -> unit) -> 'a option -> unit val may_map: ('a -> 'b) -> 'a option -> 'b option @@ -90,15 +109,23 @@ val exact_file_exists : dirname:string -> basename:string -> bool systems: return true only if the basename (last component of the path) has the correct case. *) val find_in_path: string list -> string -> string - (* Search a file in a list of directories. *) + (** Search a file in a list of directories. *) + val find_in_path_rel: string list -> string -> string - (* Search a relative file in a list of directories. *) -val find_in_path_uncap: ?fallback:string -> string list -> string -> string - (* Same, but search also for uncapitalized name, i.e. - if name is Foo.ml, allow /path/Foo.ml and /path/foo.ml - to match. *) + (** Search a relative file in a list of directories. *) + + (** Normalize file name [Foo.ml] to [foo.ml] *) +val normalized_unit_filename: string -> string + +val find_in_path_normalized: ?fallback:string -> string list -> string -> string +(** Same as {!find_in_path_rel} , but search also for normalized unit filename, + i.e. if name is [Foo.ml], allow [/path/Foo.ml] and [/path/foo.ml] to + match. *) + + val canonicalize_filename : ?cwd:string -> string -> string (* Ensure that path is absolute (wrt to cwd), by following ".." and "." *) + val expand_glob : ?filter:(string -> bool) -> string -> string list -> string list (* [expand_glob ~filter pattern acc] adds all filenames matching [pattern] and satistfying the [filter] predicate to [acc]*) @@ -111,9 +138,12 @@ val split_path : string -> string list -> string list *) val remove_file: string -> unit - (* Delete the given file if it exists. Never raise an error. *) + (** Delete the given file if it exists and is a regular file. + Does nothing for other kinds of files. + Never raises an error. *) + val expand_directory: string -> string -> string - (* [expand_directory alt file] eventually expands a [+] at the + (** [expand_directory alt file] eventually expands a [+] at the beginning of file into [alt] (an alternate root directory) *) val create_hashtable: int -> ('a * 'b) list -> ('a, 'b) Hashtbl.t @@ -139,7 +169,7 @@ val output_to_file_via_temporary: the channel is closed and the temporary file is renamed to [filename]. *) -val input_bytes : in_channel -> int -> bytes;; +val input_bytes : in_channel -> int -> bytes (* [input_bytes ic n] reads [n] bytes from [ic] and returns them in a new string. It raises [End_of_file] if EOF is encountered before all the bytes are read. *) @@ -163,6 +193,8 @@ val no_overflow_lsl: int -> int -> bool (* [no_overflow_lsl n k] returns [true] if the computation of [n lsl k] does not overflow. *) +val letter_of_int : int -> string + module Int_literal_converter : sig val int : string -> int val int32 : string -> int32 @@ -170,6 +202,27 @@ module Int_literal_converter : sig val nativeint : string -> nativeint end +val find_first_mono : (int -> bool) -> int + (**[find_first_mono p] takes an integer predicate [p : int -> bool] + that we assume: + 1. is monotonic on natural numbers: + if [a <= b] then [p a] implies [p b], + 2. is satisfied for some natural numbers in range [0; max_int] + (this is equivalent to: [p max_int = true]). + + [find_first_mono p] is the smallest natural number N that satisfies [p], + computed in O(log(N)) calls to [p]. + + Our implementation supports two cases where the preconditions on [p] + are not respected: + - If [p] is always [false], we silently return [max_int] + instead of looping or crashing. + - If [p] is non-monotonic but eventually true, + we return some satisfying value. + *) + +(** {1 String operations} *) + val chop_extension_if_any: string -> string (* Like Filename.chop_extension but returns the initial file name if it has no extension *) @@ -224,21 +277,6 @@ val for4: 'a * 'b * 'c * 'd -> 'd * - modules_in_path ~ext:".mli" ["."] returns ["A"] *) val modules_in_path : ext:string -> string list -> string list -val file_contents : string -> string - -module LongString : - sig - type t = bytes array - val create : int -> t - val length : t -> int - val get : t -> int -> char - val set : t -> int -> char -> unit - val blit : t -> int -> t -> int -> int -> unit - val output : out_channel -> t -> int -> int -> unit - val unsafe_blit_to_bytes : t -> int -> bytes -> int -> int -> unit - val input_bytes : in_channel -> int -> t - end - val edit_distance : string -> string -> int -> int option (** [edit_distance a b cutoff] computes the edit distance between strings [a] and [b]. To help efficiency, it uses a cutoff: if the @@ -315,8 +353,18 @@ val ordinal_suffix : int -> string [4] -> ["th"], and so on. Handles larger numbers (e.g., [42] -> ["nd"]) and the numbers 11--13 (which all get ["th"]) correctly. *) -(* Color handling *) -module Color : sig +(** {1 Color support detection }*) +module Color: sig + type setting = Auto | Always | Never + + val default_setting : setting + +end + + +(** {1 Styling handling for terminal output } *) + +module Style : sig type color = | Black | Red @@ -326,7 +374,6 @@ module Color : sig | Magenta | Cyan | White - ;; type style = | FG of color (* foreground *) @@ -339,25 +386,35 @@ module Color : sig val ansi_of_style_l : style list -> string (* ANSI escape sequence for the given style *) + type tag_style ={ + ansi: style list; + text_open:string; + text_close:string + } + type styles = { - error: style list; - warning: style list; - loc: style list; + error: tag_style; + warning: tag_style; + loc: tag_style; + hint: tag_style; + inline_code: tag_style; } + val as_inline_code: (Format.formatter -> 'a -> unit as 'printer) -> 'printer + val inline_code: Format.formatter -> string -> unit + val default_styles: styles val get_styles: unit -> styles val set_styles: styles -> unit - type setting = Auto | Always | Never - - val default_setting : setting - - val setup : setting option -> unit + val setup : Color.setting option -> unit (* [setup opt] will enable or disable color handling on standard formatters according to the value of color setting [opt]. Only the first call to this function has an effect. *) - val set_color_tag_handling : Format.formatter -> unit + val set_tag_handling : Format.formatter -> unit (* adds functions to support color tags to the given formatter. *) end + +val print_see_manual : Format.formatter -> int list -> unit +(** See manual section *) diff --git a/src/utils/std.ml b/src/utils/std.ml index 433e1b9527..9cc9de0932 100644 --- a/src/utils/std.ml +++ b/src/utils/std.ml @@ -224,6 +224,14 @@ module List = struct let acc, xs' = fold_n_map ~f ~init:acc xs in acc, (x' :: xs') + let rec iteri2 i ~f l1 l2 = + match (l1, l2) with + ([], []) -> () + | (a1::l1, a2::l2) -> f i a1 a2; iteri2 (i + 1) ~f l1 l2 + | (_, _) -> raise (Invalid_argument "iteri2") + + let iteri2 ~f l1 l2 = iteri2 0 ~f l1 l2 + module Lazy = struct type 'a t = | Nil @@ -343,9 +351,7 @@ module Option = struct end module Result = struct - type ('a, 'e) t = ('a, 'e) result = - | Ok of 'a - | Error of 'e + include Result let map ~f r = Result.map f r let bind ~f r = Result.bind r f @@ -449,15 +455,11 @@ module String = struct let print () s = Printf.sprintf "%S" s - (* FIXME: Remove once we drop support for 4.02 and replace the calls by their - [_ascii] version. *) - [@@@ocaml.warning "-3"] - - let capitalize = capitalize - let uncapitalize = uncapitalize + let capitalize = capitalize_ascii + let uncapitalize = uncapitalize_ascii - let lowercase = lowercase - let uppercase = uppercase + let lowercase = lowercase_ascii + let uppercase = uppercase_ascii let split_on_char_ c s = match String.index s c with @@ -623,8 +625,8 @@ module Char = struct [@@@ocaml.warning "-3"] include Char - let is_lowercase c = lowercase c = c - let is_uppercase c = uppercase c = c + let is_lowercase c = lowercase_ascii c = c + let is_uppercase c = uppercase_ascii c = c let is_strictly_lowercase c = not (is_uppercase c) let is_strictly_uppercase c = not (is_lowercase c) end diff --git a/tests/test-dirs/completion/kind.t/run.t b/tests/test-dirs/completion/kind.t/run.t index d6aefecb6b..d30c518db8 100644 --- a/tests/test-dirs/completion/kind.t/run.t +++ b/tests/test-dirs/completion/kind.t/run.t @@ -25,8 +25,6 @@ Keywords only including extension: $ echo "f" | $MERLIN single complete-prefix -position 1:2 -filename test.ml \ > -kind k -prefix f -extension lwt | jq ".value.entries[].name" - "finally" - "for_lwt" "function" "false" "fun" @@ -44,7 +42,9 @@ certain path "filteri" "find" "find_all" + "find_index" "find_map" + "find_mapi" "find_opt" "flatten" "fold_left" diff --git a/tests/test-dirs/config/dot-merlin-reader/load-config.t b/tests/test-dirs/config/dot-merlin-reader/load-config.t new file mode 100644 index 0000000000..3aeea7a183 --- /dev/null +++ b/tests/test-dirs/config/dot-merlin-reader/load-config.t @@ -0,0 +1,63 @@ +This test comes from: https://github.com/janestreet/merlin-jst/pull/59 + + $ cat > .merlin < B build/dir + > S source/dir + > BH build-hidden/dir + > SH source-hidden/dir + > EOF + + $ FILE=$(pwd)/test.ml; dot-merlin-reader < (4:File${#FILE}:$FILE) + > EOF + ((?:B?:$TESTCASE_ROOT/build/dir)(?:S?:$TESTCASE_ROOT/source/dir)(?:BH?:$TESTCASE_ROOT/build-hidden/dir)(?:SH?:$TESTCASE_ROOT/source-hidden/dir)) + + $ echo | $MERLIN single dump-configuration -filename test.ml 2> /dev/null | jq '.value.merlin' + { + "build_path": [ + "$TESTCASE_ROOT/build/dir" + ], + "source_path": [ + "$TESTCASE_ROOT/source/dir" + ], + "hidden_build_path": [ + "$TESTCASE_ROOT/build-hidden/dir" + ], + "hidden_source_path": [ + "$TESTCASE_ROOT/source-hidden/dir" + ], + "cmi_path": [], + "cmt_path": [], + "flags_applied": [], + "extensions": [], + "suffixes": [ + { + "impl": ".ml", + "intf": ".mli" + }, + { + "impl": ".re", + "intf": ".rei" + } + ], + "stdlib": null, + "reader": [], + "protocol": "json", + "log_file": null, + "log_sections": [], + "flags_to_apply": [], + "failures": [], + "assoc_suffixes": [ + { + "extension": ".re", + "reader": "reason" + }, + { + "extension": ".rei", + "reader": "reason" + } + ], + "cache_lifespan": "5" + } + + $ rm .merlin diff --git a/tests/test-dirs/config/dot-merlin-reader/quoting.t b/tests/test-dirs/config/dot-merlin-reader/quoting.t index b9ae8c7eee..f8d0604e58 100644 --- a/tests/test-dirs/config/dot-merlin-reader/quoting.t +++ b/tests/test-dirs/config/dot-merlin-reader/quoting.t @@ -14,6 +14,8 @@ { "build_path": [], "source_path": [], + "hidden_build_path": [], + "hidden_source_path": [], "cmi_path": [], "cmt_path": [], "flags_applied": [ diff --git a/tests/test-dirs/config/hidden-deps.t b/tests/test-dirs/config/hidden-deps.t new file mode 100644 index 0000000000..ff857768c5 --- /dev/null +++ b/tests/test-dirs/config/hidden-deps.t @@ -0,0 +1,76 @@ + + $ cat >main.ml <<'EOF' + > let _ = print_int Vlib.x + > EOF + + $ mkdir hsrc + $ cat >hsrc/hlib.ml <<'EOF' + > let x = 42 + > EOF + + $ mkdir vsrc + $ cat >vsrc/vlib.ml <<'EOF' + > include Hlib + > EOF + + $ mkdir _build + $ mkdir _build/hsrc + $ mkdir _build/vsrc + + $ cp main.ml _build/main.ml + $ cp hsrc/hlib.ml _build/hsrc/hlib.ml + $ cp vsrc/vlib.ml _build/vsrc/vlib.ml + + $ (cd _build/hsrc && $OCAMLC -c -bin-annot hlib.ml ) + $ (cd _build/vsrc && $OCAMLC -c -bin-annot vlib.ml -I ../hsrc ) + $ (cd _build && $OCAMLC -c -bin-annot main.ml -I vsrc) + + $ cat >.merlin <<'EOF' + > B _build + > B _build/vsrc + > BH _build/hsrc + > S . + > S vsrc + > SH hsrc + > EOF + + $ $MERLIN single errors -filename main.ml